Yellowstone examples

let mut client = GeyserGrpcClient::build_from_shared(endpoint)?
    .x_token(Some(token))?
    .max_decoding_message_size(64 * 1024 * 1024)
    .connect()
    .await?;

let request = SubscribeRequest {
    transactions: HashMap::from([(
        "transactions".to_string(),
        SubscribeRequestFilterTransactions {
            vote: Some(false),
            failed: Some(false),
            account_include: vec![program],
            ..Default::default()
        },
    )]),
    commitment: Some(CommitmentLevel::Processed as i32),
    ..Default::default()
};

let (mut sink, mut updates) = client.subscribe_with_request(Some(request)).await?;
while let Some(update) = updates.next().await {
    match update?.update_oneof {
        Some(UpdateOneof::Ping(_)) => {
            sink.send(SubscribeRequest {
                ping: Some(SubscribeRequestPing { id: 1 }),
                ..Default::default()
            })
            .await?;
        }
        Some(UpdateOneof::Transaction(tx)) => {
            let info = tx.transaction.unwrap();
            println!("{} {}", tx.slot, bs58::encode(info.signature).into_string());
        }
        _ => {}
    }
}

import Client, { CommitmentLevel } from "@triton-one/yellowstone-grpc";
import bs58 from "bs58";

const client = new Client(endpoint, token, { grpcMaxDecodingMessageSize: 64 * 1024 * 1024 });
await client.connect();

const empty = {
  accounts: {}, slots: {}, transactions: {}, transactionsStatus: {},
  blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [],
};
const stream = await client.subscribe({
  ...empty,
  transactions: {
    transactions: {
      vote: false,
      failed: false,
      accountInclude: [program],
      accountExclude: [],
      accountRequired: [],
    },
  },
  commitment: CommitmentLevel.PROCESSED,
});

stream.on("data", (update) => {
  if (update.ping) stream.write({ ...empty, ping: { id: 1 } });
  else if (update.transaction?.transaction) {
    console.log(update.transaction.slot, bs58.encode(update.transaction.transaction.signature));
  }
});

conn, err := grpc.NewClient("ams.rpc.sodae.io:10201",
    grpc.WithTransportCredentials(insecure.NewCredentials()),
    grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(64<<20)))
ctx := metadata.AppendToOutgoingContext(context.Background(), "x-token", token)
stream, err := pb.NewGeyserClient(conn).Subscribe(ctx)

commitment := pb.CommitmentLevel_PROCESSED
vote, failed := false, false
err = stream.Send(&pb.SubscribeRequest{
    Commitment: &commitment,
    Transactions: map[string]*pb.SubscribeRequestFilterTransactions{
        "transactions": {Vote: &vote, Failed: &failed, AccountInclude: []string{program}},
    },
})

for {
    update, err := stream.Recv()
    if err != nil {
        return err
    }
    switch u := update.UpdateOneof.(type) {
    case *pb.SubscribeUpdate_Ping:
        stream.Send(&pb.SubscribeRequest{Ping: &pb.SubscribeRequestPing{Id: 1}})
    case *pb.SubscribeUpdate_Transaction:
        fmt.Println(u.Transaction.Slot, base58.Encode(u.Transaction.Transaction.Signature))
    }
}

let mut client = GeyserGrpcClient::build_from_shared("https://ams.tls.sodae.io:443")?
    .x_token(Some(token))?
    .tls_config(ClientTlsConfig::new().with_native_roots())?
    .max_decoding_message_size(64 * 1024 * 1024)
    .connect()
    .await?;

const client = new Client("https://ams.tls.sodae.io:443", token, { grpcMaxDecodingMessageSize: 64 * 1024 * 1024 });
await client.connect();

conn, err := grpc.NewClient("ams.tls.sodae.io:443",
    grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
    grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(64<<20)))