GOSSIP_PRIORITY

Overview

The GOSSIP_PRIORITY stream provides normalized gossipPriorityBid events from Hyperliquid transaction data. It emits one JSON event per gossip-priority bid action, derived from both mempool transactions and confirmed block data.

Stream Type: GOSSIP_PRIORITY
API Availability: gRPC Streaming API only
Volume: Variable - Depends on gossip-priority auction activity

When to Use GOSSIP_PRIORITY

Use GOSSIP_PRIORITY when you want to observe gossip/read-priority auction activity without parsing raw MEMPOOL_TXS or full BLOCKS/replica_cmds payloads yourself.

Important: GOSSIP_PRIORITY does not measure whether a customer received market data faster. It only surfaces the priority-bid action when it appears in observed transaction data.

This stream is valuable for:

Gossip Auction Monitoring - Track gossip-priority bid submissions in real-time
Read-Priority Analysis - Understand gossip-priority patterns
Pre-Confirmation Visibility - See gossip-priority bids from mempool before block inclusion
Confirmation Tracking - Monitor execution outcomes for gossip-priority bids

Data Sources

The GOSSIP_PRIORITY stream derives events from two sources:

Source	Description	Additional Fields
mempool_txs	Pre-consensus gossip-priority activity from the mempool. Events are not finalized and may be rejected, reordered, or absent from the finalized chain.	first_seen_time, tx_hash
replica_cmds	Confirmed block data representing finalized transaction processing.	block_number, block_time, bundle_index, outcome

Event Structure

Mempool Event

{
  "type": "gossip",
  "source": "mempool_txs",
  "first_seen_time": "2026-06-02T13:48:49.578877529",
  "tx_hash": "0x...",
  "signed_action_index": 0,
  "maxGas": 1000000,
  "slotId": 123,
  "ip": "..."
}

Confirmed Event (replica_cmds source)

Confirmed gossip events may also include: user, broadcaster, block_number, block_time, bundle_index, outcome.

{
  "type": "gossip",
  "source": "replica_cmds",
  "block_number": 581285917,
  "block_time": "2026-06-02T13:48:49.626754186",
  "bundle_index": 0,
  "maxGas": 1000000,
  "slotId": 123,
  "ip": "...",
  "user": "0x...",
  "broadcaster": "0x..."
}

Response Fields

Field	Type	Description
type	string	Event type: "gossip"
source	string	Data source: "mempool_txs" (pre-consensus) or "replica_cmds" (confirmed)
first_seen_time	string	(mempool_txs only) ISO 8601 timestamp when first seen in mempool
tx_hash	string	Transaction hash (0x-prefixed)
signed_action_index	number	(mempool_txs only) Index of the signed action within the transaction
maxGas	number	Maximum gas for the gossip-priority bid
slotId	number	Slot ID for the gossip-priority bid
ip	string	IP address associated with the bid
block_number	number	(replica_cmds only) Block number where the action was confirmed
block_time	string	(replica_cmds only) ISO 8601 timestamp of the block
bundle_index	number	(replica_cmds only) Index of the bundle within the block
user	string	(replica_cmds only) User address
broadcaster	string	(replica_cmds only) Broadcaster address
outcome	string	(optional, replica_cmds only) Execution outcome

Filtering

The GOSSIP_PRIORITY stream supports standard gRPC field filtering. Useful filters:

Field	Example Values	Description
source	mempool_txs, replica_cmds	Filter by data source
type	gossip	Filter by event type

Filter Examples

// Get gossip priority events from mempool
filters: {
  "source": FilterValues { values: ["mempool_txs"] },
  "type": FilterValues { values: ["gossip"] }
}

// Get confirmed gossip priority events
filters: {
  "source": FilterValues { values: ["replica_cmds"] }
}

For complete filtering documentation, see Stream Filtering Guide.

Recommended Usage

For gossip-priority monitoring:

GOSSIP_PRIORITY

Customers should persist events if they need historical search. StreamData is a live stream and does not provide historical replay by itself.

gRPC Streaming

Python Example

import grpc
import json
from pb import streaming_pb2, streaming_pb2_grpc

GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000'
AUTH_TOKEN = 'your-auth-token'

def stream_gossip_priority():
    credentials = grpc.ssl_channel_credentials()
    channel = grpc.secure_channel(
        GRPC_ENDPOINT,
        credentials,
        options=[
            ('grpc.max_receive_message_length', 100 * 1024 * 1024),
        ]
    )

    stub = streaming_pb2_grpc.StreamingStub(channel)
    metadata = [('x-token', AUTH_TOKEN)]

    def request_generator():
        # Subscribe to GOSSIP_PRIORITY
        subscribe_request = streaming_pb2.SubscribeRequest()
        subscribe_request.subscribe.stream_type = streaming_pb2.StreamType.GOSSIP_PRIORITY
        yield subscribe_request

        # Keep connection alive with periodic pings
        while True:
            time.sleep(30)
            ping_request = streaming_pb2.SubscribeRequest()
            ping_request.ping.timestamp = int(time.time() * 1000)
            yield ping_request

    stream = stub.StreamData(request_generator(), metadata=metadata)

    for response in stream:
        if response.HasField('data'):
            data = json.loads(response.data.data)

            print(f"Gossip Priority Event")
            print(f"Source: {data.get('source')}")
            print(f"Slot ID: {data.get('slotId')}")
            print(f"Max Gas: {data.get('maxGas')}")
            print(f"TX Hash: {data.get('tx_hash')}")

            if data.get('source') == 'replica_cmds':
                print(f"Outcome: {data.get('outcome')}")
                print(f"Block: {data.get('block_number')}")
                print(f"User: {data.get('user')}")

            print("---")

if __name__ == "__main__":
    stream_gossip_priority()

JavaScript/Node.js Example

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000';
const AUTH_TOKEN = 'your-auth-token';

// Load proto file
const packageDefinition = protoLoader.loadSync('streaming.proto');
const proto = grpc.loadPackageDefinition(packageDefinition).hyperliquid;

// Create channel with credentials
const credentials = grpc.credentials.createSsl();
const client = new proto.Streaming(GRPC_ENDPOINT, credentials);

const metadata = new grpc.Metadata();
metadata.add('x-token', AUTH_TOKEN);

// Subscribe to GOSSIP_PRIORITY
const call = client.StreamData(metadata);

call.on('data', (response) => {
  if (response.data) {
    const data = JSON.parse(response.data.data);

    console.log(`Gossip Priority Event`);
    console.log(`Source: ${data.source}`);
    console.log(`Slot ID: ${data.slotId}`);
    console.log(`Max Gas: ${data.maxGas}`);
    console.log(`TX Hash: ${data.tx_hash}`);

    if (data.source === 'replica_cmds') {
      console.log(`Outcome: ${data.outcome}`);
      console.log(`Block: ${data.block_number}`);
      console.log(`User: ${data.user}`);
    }

    console.log('---');
  }
});

call.on('error', (error) => {
  console.error('Stream error:', error);
});

// Send subscription
call.write({
  subscribe: {
    stream_type: 10  // GOSSIP_PRIORITY
  }
});

// Send periodic pings
setInterval(() => {
  call.write({
    ping: { timestamp: Date.now() }
  });
}, 30000);

Important Notes

Derived Stream - GOSSIP_PRIORITY is a derived stream that normalizes data from MEMPOOL_TXS and BLOCKS, saving you from parsing raw payloads
Not Latency Measurement - This stream does not measure whether a customer received market data faster; it only surfaces priority-bid actions
Dual Sources - Events come from both mempool (pre-consensus) and confirmed blocks (post-consensus)
Compression - Consider enabling zstd compression on your gRPC channel for bandwidth efficiency

ORDER_PRIORITY - Priority-fee order events
MEMPOOL_TXS - Raw mempool transactions (source data for pre-consensus events)
BLOCKS - Raw blockchain data (source data for confirmed events)

For more information about gRPC streaming setup, see gRPC API Documentation.

Overview​

Data Sources​

Event Structure​

Mempool Event​

Confirmed Event (replica_cmds source)​

Response Fields​

Filtering​

Filter Examples​

Recommended Usage​

gRPC Streaming​

Important Notes​

Related Streams​