subscribeReplayInfo gRPC Method - Yellowstone

Please note that this RPC method requires the Yellowstone gRPC add-on enabled on your QuickNode endpoint.

Parameters

This method does not accept any parameters

Returns

first_available

string

Loading...

Request

package main

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

	pb "yellowstone/proto"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/encoding/gzip"
	"google.golang.org/grpc/keepalive"
)

var (
	endpoint = "YOUR_QN_ENDPOINT:10000"
	token    = "YOUR_TOKEN_NUMBER"
)

var kacp = keepalive.ClientParameters{
	Time:                10 * time.Second,
	Timeout:             time.Second,
	PermitWithoutStream: true,
}

type tokenAuth struct {
	token string
}

func (t tokenAuth) GetRequestMetadata(ctx context.Context, in ...string) (map[string]string, error) {
	return map[string]string{
		"x-token": t.token,
	}, nil
}

func (tokenAuth) RequireTransportSecurity() bool {
	return false
}

func main() {
	opts := []grpc.DialOption{
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
		grpc.WithKeepaliveParams(kacp),
		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(1024*1024*1024), grpc.UseCompressor(gzip.Name)),
		grpc.WithPerRPCCredentials(tokenAuth{token: token}),
	}

	conn, err := grpc.NewClient(endpoint, opts...)
	if err != nil {
		log.Fatalf("Failed to connect: %v", err)
	}
	defer conn.Close()

	client := pb.NewGeyserClient(conn)

	req := &pb.SubscribeReplayInfoRequest{}
	resp, err := client.SubscribeReplayInfo(context.Background(), req)
	if err != nil {
		log.Fatalf("Failed to get replay info: %v", err)
	}

	if resp.FirstAvailable != nil {
		fmt.Printf("First available slot for replay: %d\n", *resp.FirstAvailable)
	} else {
		fmt.Println("No replay information available")
	}
}

import Client from "@triton-one/yellowstone-grpc";

const ENDPOINT = "YOUR_QN_ENDPOINT:10000";
const TOKEN = "YOUR_TOKEN_NUMBER";

async function main() {
    const client = new Client(ENDPOINT, TOKEN, {});

    try {
        const response = await client.subscribeReplayInfo({});
        
        if (response.firstAvailable !== undefined) {
            console.log("First available slot for replay:", response.firstAvailable);
        } else {
            console.log("No replay information available");
        }
        
    } catch (error) {
        console.error("Error getting replay info:", error);
    }
}

main()
    .catch((err) => {
        console.error("Unhandled error:", err);
        process.exit(1);
    });

Don't have an account yet?

Create your QuickNode endpoint in seconds and start building

Get started for free