Solana Yellowstone gRPC in Go.

1. Minimum viable client

Generate Go stubs from yellowstone.proto once, then wire them up against grpc.subglow.io:443. Here's the shortest end-to-end Pump.fun subscription:

package main

import (
	"context"
	"crypto/tls"
	"log"

	pb "github.com/your-org/yellowstone-go/pb"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
)

func main() {
	// 1. TLS + connect
	creds := credentials.NewTLS(&tls.Config{})
	conn, err := grpc.NewClient(
		"grpc.subglow.io:443",
		grpc.WithTransportCredentials(creds),
	)
	if err != nil {
		log.Fatalf("dial: %v", err)
	}
	defer conn.Close()

	// 2. API key via metadata
	ctx := metadata.AppendToOutgoingContext(
		context.Background(),
		"x-token", "YOUR_SUBGLOW_API_KEY",
	)

	client := pb.NewGeyserClient(conn)
	stream, err := client.Subscribe(ctx)
	if err != nil {
		log.Fatalf("subscribe: %v", err)
	}

	// 3. Send a filter — Pump.fun program transactions only
	req := &pb.SubscribeRequest{
		Transactions: map[string]*pb.SubscribeRequestFilterTransactions{
			"pumpfun": {
				AccountInclude: []string{"6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"},
				Vote:           boolPtr(false),
				Failed:         boolPtr(false),
			},
		},
	}
	if err := stream.Send(req); err != nil {
		log.Fatalf("send filter: %v", err)
	}

	// 4. Consume
	for {
		msg, err := stream.Recv()
		if err != nil {
			log.Fatalf("recv: %v", err)
		}
		if tx := msg.GetTransaction(); tx != nil {
			log.Printf("slot=%d sig=%x", tx.Slot, tx.Transaction.Signature)
		}
	}
}

func boolPtr(b bool) *bool { return &b }

That's it — every Pump.fun transaction streams into your process. Latency on Subglow: 30–80ms from slot confirmation to stream.Recv().

3. Worker pool for high throughput

Never run decode and trading logic synchronously in the gRPC receive loop — that's how Go bots drop messages under load. Push raw messages to a buffered channel, let a pool of goroutines process them, drop (and count) if the buffer fills:

type txMsg struct {
	Slot uint64
	Sig  []byte
	Data []byte
}

func startWorkers(n int, in <-chan *txMsg) {
	for i := 0; i < n; i++ {
		go func(id int) {
			for m := range in {
				processTx(m) // decode + business logic here
			}
		}(i)
	}
}

// In the gRPC receive loop:
//   select {
//   case workCh <- msg:
//   default:
//       droppedCounter.Inc() // never block the stream
//   }

Also in other languages