CrypDefi is now Fortkey. read the announcement

    Fortkey HFT vaults

    Latency never costs you a fill.

    Pre-built signing vaults co-located with your venues and builders. Decode, policy check, and signature in under a millisecond, with MEV-protected routing.

    End-to-end signing latency

    750,000 signs · sustained

    p50

    238 µs

    p95

    296 µs

    p99

    372 µs

    p50p95p99150 µs300 µs450 µs600 µs

    99.95% of signatures under 1 ms · rolling p99 held between 348 and 392 µs across the full run · EVM, decode + policy check + sign, ecdsa secp256k1, eu-west-1, sustained single stream, July 2026

    In your perimeter, next to your algo.

    Your bot sends an unsigned payload. The vault decodes it, checks policy, and signs in microseconds, then the signed transaction executes at your venue.

    • Keys never leave the enclave
    • Policy checked before every signature
    • Control plane stays off the hot path
    UNSIGNED PAYLOAD
    SIGNED TRANSACTION
    Source
    Your bot
    Algo / Bot SDK
    Live
    Fortkey HFT Vault
    Attested enclave
    01
    Decode
    02
    Policy
    03
    Sign
    Policy compiled ahead of runtime
    Destination
    Any venue
    Hyperliquid, Drift
    Routed

    Algorithmic by design.

    Authenticate, open a wallet session, and sign the orders your bot builds. Keys stay in the enclave. The Rust SDK and REST API drive the same secured keys and policies as manual trading.

    • Rust SDK and REST API
    • Keys generated inside the enclave on first call
    • Same keys and policies as FortkeyLink manual trading
    use fortkey_hft_sdk::{bytes_to_hex, BotTrader, TxKind, UserId};
    
    #[tokio::main]
    async fn main() -> anyhow::Result<()> {
        // Challenge-response auth with your bot key. No static API keys.
        let pem = std::fs::read_to_string("bot-key.pem")?;
        let mut sdk = BotTrader::new(pem.trim(), UserId::new("us-mm-eu-01")?)?;
        sdk.login().await?;
    
        // Pin an enclave co-located with your venue, then open a wallet session.
        sdk.use_signing_instance("eu-central-1", None, None, None).await?;
        sdk.start_wallet_session("mm-eu-perps", "eu-central-1").await?;
    
        // Your strategy builds the order; Fortkey signs it inside the enclave.
        let order: Vec<u8> = build_order();
        let sig = sdk.sign_tx("mm-eu-perps", &order, TxKind::EvmEip712).await?;
        println!("signature: {}", bytes_to_hex(&sig.to_der()?));
    
        sdk.logout().await?;
        Ok(())
    }

    Payload-aware, compiled inline.

    Policies and payload validations are compiled for your use cases ahead of time and run inline with the signing engine, in the same enclave.

    • No external call to sign
    • Full control over what you sign
    • Sub-1ms end to end, benchmarked

    Benchmarked end to end: decode, policy check, and signature at 372 µs p99, across 750,000 sustained EVM signs.

    The usual way20+ ms
    External signer + network round-trip

    A remote signing call is required for every signature.

    With Fortkey<1 ms signing
    Policy and signing inline in the enclave

    No external signing call. Keys remain isolated.

    Under 1 ms is the end-to-end vault path (decode, policy check, and signature) on our EVM benchmark series in eu-west-1. Network time to your venue depends on colocation, and figures vary by chain.

    Multi-region signing, MEV-protected routing.

    Signing replicas in Ireland, Tokyo, and more on demand, latency-routed so bots sign next to the closest venue.

    • Replicas placed next to block builders
    • Private order-flow routing by default
    • Cancel-on-disconnect: session drops trigger automatic cancels at the venue
    ashburn
    secaucus
    salt lake city
    dublin
    london
    amsterdam
    frankfurt
    tokyo
    singapore
    fortkey locationblock builder
    builder topology

    A real-world use case

    A market maker cut signing latency by more than 90 percent

    In a sandbox benchmark against its existing signer setup, a market-making desk measured a latency reduction of more than 90 percent on the signing path, with custody unchanged and every order checked against policy.

    p99 372 µs

    end-to-end signing, benchmarked

    9 chain families

    EVM, Solana, Canton, and 6 more

    Multi-region

    co-located with leading builders and venues

    Benchmarked end to end on our EVM series in eu-west-1: decode, policy check, and signature across 750,000 sustained single-stream signs. Request the current methodology note.