Makers

pAMM Quote WebSocket

This endpoint is reserved for trading firms operating a prop AMM on Ethereum who want to land quote updates in Titan blocks. Access is API-key gated, please reach out if you want access.

Behavioural properties

Maker priority

The builder provides two defences against being picked off on latency.

Taker ordering. When a taker trade against the pool is included in a block, the latest applicable quote update is guaranteed to be placed before it in the same block.

Maker freshness protection. A per-session freshness buffer b, set at onboarding, can be applied to takers routing against your pool. A taker is only eligible to trade against a quote update if the taker was received by the builder at least b before that quote update was received:

taker_recv + b < quote_update_recv

For example, with b = 50ms, a quote update received at time T can only be matched against takers received before T - 50ms.

This reduces exposure to toxic takers attempting to snipe stale quotes, while also protecting makers in case of quote streaming failures mid-slot.

Fast replacements and cancellations

Quotes sent through this endpoint take the fastest path to the builders. We have cores dedicated to simulating and applying these bundles efficiently. Cancellations are more consistent due to stricter block overwrite rules.

Conditional inclusion

Quote transactions can either land every block, or only when a taker in the block trades against the pool. The builder evaluates each candidate tx against every live quote and, in conditional mode, includes the latest quote update immediately before any matching taker - quotes that are never matched never go onchain.

Authentication

Authentication uses an API key shared directly when access is granted. Specify it in the Authorization header when establishing the WebSocket connection.

Endpoints

Use the following regional endpoints to get the lowest latency between your quote publisher and our clusters. Higher-performance URLs (direct access) are available on request.

Region	Endpoint
eu-central-1	wss://eu.rpc.titanbuilder.xyz/ws/sendquoteupdate
ap-northeast-1	wss://ap.rpc.titanbuilder.xyz/ws/sendquoteupdate
us-east-1	wss://us.rpc.titanbuilder.xyz/ws/sendquoteupdate

Submit quote (ws/sendquoteupdate)

message PWebsocketQuoteUpdateV1Args {
  // RLP-encoded quote-update tx bytes. Empty = cancel the replacement_uuid.
  bytes tx = 1;
  // single block this quote is valid for
  uint64 block_number = 2;
  // 16-byte quote identifier (raw UUID bytes).
  bytes replacement_uuid = 3;
  // monotonic per uuid (>0)
  uint64 replacement_seq_number = 4;
  // quotes will not be shared between builder regions
  bool disable_cross_region_sharing = 5;
}

replacement_uuid must be set and exactly 16 bytes. replacement_seq_number must be set and strictly greater than the previous value seen under the same replacement_uuid and cannot be 0. Messages violating either constraint are dropped.

We recommend setting disable_cross_region_sharing to true. Otherwise we broadcast your quotes internally across regions, which adds latency you do not control. For best results, run edge nodes next to each of our regional clusters and send directly to the closest.

Cancel quotes

Send a PWebsocketQuoteUpdateV1Args with tx empty, replacement_uuid set to the quote you want to pull, and a strictly greater replacement_seq_number than the last update under that uuid.

Response

message PWebsocketQuoteUpdateV1Response {
  // Quote identifier being acknowledged.
  bytes replacement_uuid = 1;
  uint64 replacement_seq_number = 2;
  // RPC receive UNIX nanos.
  uint64 timestamp = 3;
  // Empty on success. Populated with error detail on failure.
  string error = 4;
}

Match responses to submits on (replacement_uuid, replacement_seq_number). Use timestamp minus your local send-time to measure end-to-end latency.

Example (Rust)

// Generate the `pb` module from the .proto above using prost-build.

use std::io::ErrorKind;
use tungstenite::{client::IntoClientRequest, stream::MaybeTlsStream, Message as WsMessage};
use prost::Message;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut req = "wss://eu.rpc.titanbuilder.xyz/ws/sendquoteupdate".into_client_request()?;
    req.headers_mut().insert("Authorization", "YOUR_API_KEY".parse()?);

    let (mut ws, _) = tungstenite::connect(req)?;

    if let MaybeTlsStream::Plain(s) = ws.get_mut() {
        s.set_nodelay(true)?;
        s.set_nonblocking(true)?;
    }

    let mut buf = Vec::with_capacity(4096);
    let mut seq: u64 = 0;

    loop {
        seq += 1;
        let quote = pb::PWebsocketQuoteUpdateV1Args {
            tx: vec![/* RLP-encoded signed quote-update tx */],
            block_number: 1234,
            replacement_uuid: vec![/* 16 bytes */],
            replacement_seq_number: seq,
            disable_cross_region_sharing: true,
        };

        buf.clear();
        quote.encode(&mut buf)?;

        match ws.send(WsMessage::Binary(buf.into())) {
            Ok(()) => {}
            Err(tungstenite::Error::Io(e)) if e.kind() == ErrorKind::WouldBlock => {}
            Err(e) => return Err(e.into()),
        }

        match ws.read() {
            Ok(WsMessage::Binary(bytes)) => {
                let _resp = pb::PWebsocketQuoteUpdateV1Response::decode(&*bytes)?;
                // latency = match on (replacement_uuid, replacement_seq_number)
            }
            Ok(_) => {}
            Err(tungstenite::Error::Io(e)) if e.kind() == ErrorKind::WouldBlock => {}
            Err(e) => return Err(e.into()),
        }
    }
}

Pricing

Quote updates submitted through this endpoint do not pay priority fees.

Instead, makers are charged a volume-based fee on filled trades. Fees are configured on a per-pair basis. Pricing may differ across assets depending on market structure and quoting behaviour, though fees across makers are the same.

During the initial testing phase, fee discounts are active while we collect data on spreads, fill quality, and realised markouts across different markets. We expect to move to a more stable and publicly documented fee schedule once the system has been sufficiently tested and pricing can be calibrated from production data. Please reach out directly for more information on current pricing.

Permissionless Access

We're also exploring opening these guarantees up permissionlessly. For example, we are exploring supporting this initiative: https://github.com/flashbots/priority-update-registry