AllenHark Relay — Client Integration Guide

Introduction

AllenHark Relay is an ultra-low-latency Solana transaction relay designed for traders, market makers, and automated systems requiring sub-millisecond dispatch.

Your client submits a pre-signed Solana transaction to AllenHark Relay, and we immediately deliver it using a highly optimized, leader-aware pipeline engineered for speed.

Submission Modes

We provide two submission modes:

A) QUIC (Recommended — 0.1ms possible)

Persistent, connection-oriented, extremely low overhead.

B) Standard HTTPS

Simplest integration, but typically 15–25ms latency.

Relay Endpoints

• Domain: relay.allenhark.com
• IP: 151.241.71.10
• Region: Frankfurt, Germany

[!IMPORTANT] Regional Notice: AllenHark Relay is currently hosted in the Frankfurt region.

• QUIC Protocol (Recommended): Works efficiently from any location worldwide
• HTTPS/REST: Only recommended if your services are also in Frankfurt. For all other regions, use QUIC for optimal performance.

Tip Wallets

To access the relay, every request must include a valid on-chain tip. This ensures fairness, prevents spam, and supports the economic incentive layer behind the relay's performance.

Available Tip Wallets (Select Random):

1const TIP_WALLETS = [
2  "harkm2BTWxZuszoNpZnfe84jRbQTg6KGHaQBmWzDGQQ",
3  "hark1zxc5Rz3K8Kquz79WPWFEgNCFeJnsMJ16f22uNP",
4  "hark6hUDUTekc1DGxWdJcuyDZwf6pJdCxd4SXAVtta6",
5  "harkbPLc5b5ifQrJoTMW1jRNeqa8GakYinJ71tYAkR9",
6  "harkoJfnM6dxrJydx5eVmDVwAgwC94KbhuxF69UbXwP",
7];
8
9// Select a random tip wallet for each request
10const tipWallet = TIP_WALLETS[Math.floor(Math.random() * TIP_WALLETS.length)];

1// Rust example
2const TIP_WALLETS: [&str; 5] = [
3    "harkm2BTWxZuszoNpZnfe84jRbQTg6KGHaQBmWzDGQQ",
4    "hark1zxc5Rz3K8Kquz79WPWFEgNCFeJnsMJ16f22uNP",
5    "hark6hUDUTekc1DGxWdJcuyDZwf6pJdCxd4SXAVtta6",
6    "harkbPLc5b5ifQrJoTMW1jRNeqa8GakYinJ71tYAkR9",
7    "harkoJfnM6dxrJydx5eVmDVwAgwC94KbhuxF69UbXwP",
8];
9
10// Select a random tip wallet
11let tip_wallet = TIP_WALLETS[rand::random::<usize>() % TIP_WALLETS.len()];

Your client must include the tip signature alongside your transaction payload.

Rate Limits

• Default: 50 requests per second per IP
• Custom Private Address: Available for users exceeding 1,000 transactions per day
• Custom Limits: Contact us for dedicated rate limits and private tip addresses

[!TIP] For high-volume usage (>1k tx/day), contact our team to request a custom private tip address and increased rate limits.

Minimum Tip Amount

AllenHark Relay requires a minimum tip for each relay request:

• Minimum: 0.001 SOL (1,000,000 lamports)
• Recommended during congestion: 0.002–0.005 SOL

Requests without a tip or with insufficient tip return:

Sending via QUIC (Recommended)

QUIC provides:

• Persistent sessions
• Sub-millisecond acknowledgments
• Zero TCP handshake cost
• Ideal for bots, market makers, and colocated clients

QUIC Endpoint

Packet Format

1struct ClientPacket {
2  u8 version;
3  u8 encoding;      // 1 = binary, 2 = JSON (dev mode)
4  u16 tx_length;
5  bytes transaction;
6  bytes tip_signature;
7}

Rust Example (quinn)

1use quinn::{ClientConfig, Endpoint};
2use std::sync::Arc;
3
4#[tokio::main]
5async fn main() -> Result<(), Box<dyn std::error::Error>> {
6    let mut endpoint = Endpoint::client("0.0.0.0:0".parse().unwrap())?;
7    let client_config = ClientConfig::with_native_roots();
8    endpoint.set_default_client_config(client_config);
9
10    // Connect to relay
11    let connection = endpoint
12        .connect("151.241.71.10:4433".parse().unwrap(), "relay.allenhark.com")?
13        .await?;
14
15    println!("Connected to relay");
16
17    // Open a stream
18    let (mut send, _) = connection.open_bi().await?;
19
20    // Construct packet (simplified)
21    let packet = vec![ /* ... serialized ClientPacket ... */ ];
22    
23    send.write_all(&packet).await?;
24    send.finish().await?;
25
26    Ok(())
27}

Node.js Note

Node.js QUIC support is currently experimental. We recommend using Rust for QUIC integration or using the HTTPS endpoint for Node.js applications.

Sending via RPC (HTTPS)

A simpler integration path, with higher latency.

Endpoint

[!WARNING] Not Recommended for Non-Frankfurt Regions: HTTPS/REST has significantly higher latency (15-25ms) and is only suitable if your infrastructure is also in Frankfurt. For all other locations, use QUIC protocol instead.

Node.js Example (fetch)

1const response = await fetch("https://relay.allenhark.com/v1/sendTx", {
2  method: "POST",
3  headers: {
4    "Content-Type": "application/json",
5  },
6  body: JSON.stringify({
7    jsonrpc: "2.0",
8    id: 1,
9    method: "sendTransaction",
10    params: [
11      base58SignedTransaction,
12      {
13        skipPreflight: true,
14        commitment: "processed",
15      },
16    ],
17  }),
18});
19
20const data = await response.json();
21console.log("Response:", data);

Rust Example (reqwest)

1use reqwest::Client;
2use serde_json::json;
3
4#[tokio::main]
5async fn main() -> Result<(), Box<dyn std::error::Error>> {
6    let client = Client::new();
7    
8    let res = client.post("https://relay.allenhark.com/v1/sendTx")
9        .json(&json!({
10            "jsonrpc": "2.0",
11            "id": 1,
12            "method": "sendTransaction",
13            "params": [
14                "base58_signed_transaction...",
15                {
16                    "skipPreflight": true,
17                    "commitment": "processed"
18                }
19            ]
20        }))
21        .send()
22        .await?;
23
24    println!("Status: {}", res.status());
25    Ok(())
26}

Keep-Alive Best Practices

QUIC Keep-Alive

Recommended settings:

• Keep-alive ping: every 3 seconds
• Timeout: 10–15 seconds

Benefits:

• No reconnection cost
• Predictable 0.1ms dispatch
• Session stability for high-frequency bots

1const client = new QuicClient("relay.allenhark.com:4433", {
2  keepAlive: true,
3  keepAliveInterval: 3000,
4  keepAliveTimeout: 15000,
5});

HTTPS Keep-Alive

If you are using Axios:

1import axios from "axios";
2import https from "https";
3
4const agent = new https.Agent({ keepAlive: true });
5
6const api = axios.create({
7  baseURL: "https://relay.allenhark.com",
8  httpsAgent: agent,
9});

This reduces repeated TLS handshakes but cannot match QUIC performance.

Response Format

Success Response

1{
2  "status": "success",
3  "signature": "5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW",
4  "slot": 250123456,
5  "dispatchTime": 0.8
6}

Error Responses

Performance Metrics

Latency Breakdown

Throughput

• QUIC: Up to 10,000 tx/s per connection
• HTTPS: Up to 1,000 tx/s per connection

Co-Locate With Us for True 0.1ms Performance

For the absolute lowest latency, we strongly encourage clients to co-locate their bots or trading engines with us.

Colocation Benefits

• Direct, private, ultra-fast link to the relay
• True sub-millisecond transaction dispatch
• Leader-aware execution
• Guaranteed throughput
• Access to private QUIC lanes
• Priority engineering support

Colocation Locations

• Tokyo: Equinix TY3
• New York: Equinix NY5
• London: Equinix LD5 (coming soon)

Get in touch with us to secure a colocation slot.

Contact Us | View Co-Location Details

Monitoring & Debugging

Health Check

1curl https://relay.allenhark.com/health

Response:

1{
2  "status": "healthy",
3  "latency": 0.5,
4  "uptime": 99.99,
5  "activeConnections": 1234
6}

Transaction Status

1const status = await axios.get(
2  `https://relay.allenhark.com/v1/status/${signature}`
3);
4
5console.log(status.data);
6// {
7//   "confirmed": true,
8//   "slot": 250123456,
9//   "confirmations": 32
10// }

Best Practices

1. Use QUIC for Production: Always use QUIC for production trading systems
2. Implement Retry Logic: Handle network errors with exponential backoff
3. Monitor Tip Amounts: Increase tips during network congestion
4. Keep Connections Alive: Maintain persistent connections for best performance
5. Co-locate if Possible: For true 0.1ms, co-locate your infrastructure
6. Test on Devnet First: Always test integration on devnet before mainnet

Support

For technical support or colocation inquiries:

• Email: relay@allenhark.com
• Discord: Join our server
• Documentation: Full API Reference