// Browser WebSocket (uses query parameter for auth)
const ws = new WebSocket(
  'wss://nexus.fortiblox.com/geyser/ws?api-key=fbx_YOUR_KEY_HERE'
);

ws.onopen = () => {
  console.log('✅ Connected to FortiBlox');
  // Connected! Transactions will stream automatically
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);

  if (data.type === 'connected') {
    console.log('WebSocket ready:', data.message);
  } else if (data.type === 'transaction') {
    console.log('New transaction:', data.data.signature);
  }
};

ws.onerror = (error) => {
  console.error('WebSocket error:', error);
};

// Node.js with ws library (uses headers for auth)
const WebSocket = require('ws');

const ws = new WebSocket('wss://nexus.fortiblox.com/geyser/ws', {
  headers: {
    'X-API-Key': 'fbx_YOUR_KEY_HERE'
  }
});

ws.on('open', () => {
  console.log('✅ Connected to FortiBlox');
  // Transactions stream automatically - no subscription needed
});

ws.on('message', (data) => {
  const message = JSON.parse(data);

  if (message.type === 'connected') {
    console.log('WebSocket ready:', message.message);
  } else if (message.type === 'transaction') {
    console.log('New transaction:', message.data.signature);
  }
});

ws.on('error', (error) => {
  console.error('WebSocket error:', error);
});

import asyncio
import websockets
import json

async def stream_transactions():
    uri = 'wss://nexus.fortiblox.com/geyser/ws?api-key=fbx_YOUR_KEY_HERE'

    async with websockets.connect(uri) as ws:
        print('✅ Connected to FortiBlox')
        # Transactions stream automatically - no subscription needed

        # Listen for messages
        async for message in ws:
            data = json.loads(message)

            if data['type'] == 'connected':
                print(f"WebSocket ready: {data['message']}")
            elif data['type'] == 'transaction':
                print(f"New transaction: {data['data']['signature']}")

asyncio.run(stream_transactions())

use tokio_tungstenite::{connect_async, tungstenite::Message};
use futures_util::{StreamExt, SinkExt};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = "fbx_YOUR_KEY_HERE";
    let url = format!(
        "wss://nexus.fortiblox.com/geyser/ws?api-key={}",
        api_key
    );

    // Connect to WebSocket
    let (ws_stream, _) = connect_async(&url).await?;
    println!("✅ Connected to FortiBlox");

    let (mut write, mut read) = ws_stream.split();

    // Transactions stream automatically - no subscription needed

    // Listen for messages
    while let Some(msg) = read.next().await {
        match msg {
            Ok(Message::Text(text)) => {
                let data: serde_json::Value = serde_json::from_str(&text)?;

                if data["type"] == "connected" {
                    println!("WebSocket ready: {}", data["message"]);
                } else if data["type"] == "transaction" {
                    println!(
                        "New transaction: {}",
                        data["data"]["signature"]
                    );
                }
            }
            Ok(Message::Close(_)) => {
                println!("Connection closed");
                break;
            }
            Err(e) => {
                eprintln!("WebSocket error: {}", e);
                break;
            }
            _ => {}
        }
    }

    Ok(())
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "os/signal"

    "github.com/gorilla/websocket"
)

type ConnectedMessage struct {
    Type    string `json:"type"`
    Message string `json:"message"`
}

type TransactionMessage struct {
    Type      string `json:"type"`
    Timestamp string `json:"timestamp"`
    Data      struct {
        Signature string `json:"signature"`
        Slot      int64  `json:"slot"`
    } `json:"data"`
}

func main() {
    apiKey := "fbx_YOUR_KEY_HERE"
    url := fmt.Sprintf(
        "wss://nexus.fortiblox.com/geyser/ws?api-key=%s",
        apiKey,
    )

    // Connect to WebSocket
    conn, _, err := websocket.DefaultDialer.Dial(url, nil)
    if err != nil {
        log.Fatal("Connection error:", err)
    }
    defer conn.Close()

    fmt.Println("✅ Connected to FortiBlox")
    // Transactions stream automatically - no subscription needed

    // Handle interrupt signal
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt)

    // Listen for messages
    done := make(chan struct{})

    go func() {
        defer close(done)
        for {
            var msg TransactionMessage
            err := conn.ReadJSON(&msg)
            if err != nil {
                log.Println("Read error:", err)
                return
            }

            if msg.Type == "connected" {
                fmt.Printf("WebSocket ready\n")
            } else if msg.Type == "transaction" {
                fmt.Printf("New transaction: %s\n", msg.Data.Signature)
            }
        }
    }()

    // Wait for interrupt or connection close
    select {
    case <-done:
        return
    case <-interrupt:
        fmt.Println("\nDisconnecting...")
        conn.WriteMessage(
            websocket.CloseMessage,
            websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""),
        )
        return
    }
}