Getting Started with Vortex

use futures::{sink::SinkExt, stream::StreamExt};
use std::collections::HashMap;
use yellowstone_grpc_client::GeyserGrpcClient;
use yellowstone_grpc_proto::prelude::{
    subscribe_update::UpdateOneof, CommitmentLevel, SubscribeRequest,
    SubscribeRequestFilterTransactions,
};
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = GeyserGrpcClient::build_from_shared("http://fra.vortex.raiden.wtf:10001")?
        .connect()
        .await?;
 
    let mut transactions = HashMap::new();
    transactions.insert(
        "pumpfun".to_owned(),
        SubscribeRequestFilterTransactions {
            vote: Some(false),
            failed: Some(false),
            account_include: vec!["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P".to_owned()],
            account_exclude: vec![],
            account_required: vec![],
            signature: None,
        },
    );
 
    // blocks, blocks_meta and entry are deliberately absent: Vortex serves
    // accounts, transactions and slots.
    let request = SubscribeRequest {
        transactions,
        commitment: Some(CommitmentLevel::Processed as i32),
        ..Default::default()
    };
 
    let (mut sink, mut stream) = client.subscribe().await?;
    sink.send(request).await?;
 
    while let Some(message) = stream.next().await {
        if let Some(UpdateOneof::Transaction(tx)) = message?.update_oneof {
            println!("slot {}", tx.slot);
        }
    }
    Ok(())
}

import grpc
from geyser_pb2 import SubscribeRequest, SubscribeRequestFilterTransactions
from geyser_pb2_grpc import GeyserStub
 
channel = grpc.insecure_channel("fra.vortex.raiden.wtf:10001")
stub = GeyserStub(channel)
 
def make_requests():
    yield SubscribeRequest(
        transactions={
            "pumpfun": SubscribeRequestFilterTransactions(
                vote=False,
                failed=False,
                account_include=["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"],
            ),
        },
        # blocks, blocks_meta and entry omitted: not served by Vortex
    )
 
for update in stub.Subscribe(make_requests()):
    if update.HasField("transaction"):
        print(f"slot {update.transaction.slot}")

import Client, { CommitmentLevel } from '@triton-one/yellowstone-grpc';
 
const client = new Client('http://fra.vortex.raiden.wtf:10001', undefined, undefined);
const stream = await client.subscribe();
 
stream.on('data', (update) => {
  if (update.transaction) {
    console.log(`slot ${update.transaction.slot}`);
  }
});
 
stream.write({
  accounts: {},
  slots: {},
  transactions: {
    pumpfun: {
      vote: false,
      failed: false,
      accountInclude: ['6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P'],
      accountExclude: [],
      accountRequired: [],
    },
  },
  // blocks, blocksMeta and entry omitted: not served by Vortex
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
});