subscribe gRPC Method - Solana gRPC

Solana gRPC is included with Scale plans and up. Learn more on our pricing page.

Parameters

This method does not accept any parameters

Returns

result

object

Request

1
package main
2

3
import (
4
	"context"
5
	"crypto/tls"
6
	"fmt"
7
	"log"
8
	"time"
9
	"github.com/mr-tron/base58"
10
	"encoding/json"
11

12
	pb "yellowstone/proto"
13

14
	"google.golang.org/grpc"
15
	"google.golang.org/grpc/credentials"
16
	"google.golang.org/grpc/encoding/gzip"
17
	"google.golang.org/grpc/keepalive"
18
)
19

20
// Quicknode endpoints consist of two crucial components: the endpoint name and the corresponding token
21
// For eg: QN Endpoint: https://docs-demo.solana-mainnet.quiknode.pro/abcde123456789
22
// endpoint will be: docs-demo.solana-mainnet.quiknode.pro:443  {443 is the port number for gRPC}
23
// token will be : abcde123456789
24

25
var (
26
	endpoint = "YOUR_QN_ENDPOINT:443"
27
	token    = "YOUR_TOKEN_NUMBER"
28
)
29

30
var kacp = keepalive.ClientParameters{
31
	Time:                10 * time.Second,
32
	Timeout:             time.Second,
33
	PermitWithoutStream: true,
34
}
35

36
type tokenAuth struct {
37
	token string
38
}
39

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

46
func (tokenAuth) RequireTransportSecurity() bool {
47
	return true
48
}
49

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

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

64
	client := pb.NewGeyserClient(conn)
65

66
    commitment := pb.CommitmentLevel_FINALIZED
67
    subReq := &pb.SubscribeRequest{
68
        Commitment: &commitment,
69
        BlocksMeta: map[string]*pb.SubscribeRequestFilterBlocksMeta{
70
            "blocks": {},
71
        },
72
        Slots: map[string]*pb.SubscribeRequestFilterSlots{
73
            "slots": {},
74
        },
75
    }
76

77
    d, _ := json.Marshal(subReq)
78
    fmt.Printf("Subscription request: %s\n", string(d))
79

80
    stream, err := client.Subscribe(context.Background())
81
    if err != nil {
82
        fmt.Printf("Failed to subscribe to yellowstone: %v\n", err)
83
        return
84
    }
85

86
    if err = stream.Send(subReq); err != nil {
87
        fmt.Printf("Failed to send subscription request: %v\n", err)
88
        return
89
    }
90

91
    for {
92
        m, err := stream.Recv()
93
        if err != nil {
94
            fmt.Printf("Failed to receive yellowstone message: %v\n", err)
95
            return
96
        }
97

98
        switch {
99
        case m.GetBlock() != nil:
100
            fmt.Printf("Block: %d\n", m.GetBlock().GetBlockHeight().GetBlockHeight())
101
        case m.GetBlockMeta() != nil:
102
            fmt.Printf("BlockMeta: %d\n", m.GetBlockMeta().GetBlockHeight().GetBlockHeight())
103
        case m.GetTransaction() != nil:
104
            fmt.Printf("Transaction: %s\n", base58.Encode(m.GetTransaction().GetTransaction().GetSignature()))
105
        case m.GetSlot() != nil:
106
            fmt.Printf("Slot: %d\n", m.GetSlot().GetSlot())
107
        }
108
    }
109
}
110

1
package main
2

3
import (
4
	"context"
5
	"crypto/tls"
6
	"fmt"
7
	"log"
8
	"time"
9
	"github.com/mr-tron/base58"
10
	"encoding/json"
11

12
	pb "yellowstone/proto"
13

14
	"google.golang.org/grpc"
15
	"google.golang.org/grpc/credentials"
16
	"google.golang.org/grpc/encoding/gzip"
17
	"google.golang.org/grpc/keepalive"
18
)
19

20
// Quicknode endpoints consist of two crucial components: the endpoint name and the corresponding token
21
// For eg: QN Endpoint: https://docs-demo.solana-mainnet.quiknode.pro/abcde123456789
22
// endpoint will be: docs-demo.solana-mainnet.quiknode.pro:443  {443 is the port number for gRPC}
23
// token will be : abcde123456789
24

25
var (
26
	endpoint = "YOUR_QN_ENDPOINT:443"
27
	token    = "YOUR_TOKEN_NUMBER"
28
)
29

30
var kacp = keepalive.ClientParameters{
31
	Time:                10 * time.Second,
32
	Timeout:             time.Second,
33
	PermitWithoutStream: true,
34
}
35

36
type tokenAuth struct {
37
	token string
38
}
39

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

46
func (tokenAuth) RequireTransportSecurity() bool {
47
	return true
48
}
49

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

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

64
	client := pb.NewGeyserClient(conn)
65

66
    commitment := pb.CommitmentLevel_FINALIZED
67
    subReq := &pb.SubscribeRequest{
68
        Commitment: &commitment,
69
        BlocksMeta: map[string]*pb.SubscribeRequestFilterBlocksMeta{
70
            "blocks": {},
71
        },
72
        Slots: map[string]*pb.SubscribeRequestFilterSlots{
73
            "slots": {},
74
        },
75
    }
76

77
    d, _ := json.Marshal(subReq)
78
    fmt.Printf("Subscription request: %s\n", string(d))
79

80
    stream, err := client.Subscribe(context.Background())
81
    if err != nil {
82
        fmt.Printf("Failed to subscribe to yellowstone: %v\n", err)
83
        return
84
    }
85

86
    if err = stream.Send(subReq); err != nil {
87
        fmt.Printf("Failed to send subscription request: %v\n", err)
88
        return
89
    }
90

91
    for {
92
        m, err := stream.Recv()
93
        if err != nil {
94
            fmt.Printf("Failed to receive yellowstone message: %v\n", err)
95
            return
96
        }
97

98
        switch {
99
        case m.GetBlock() != nil:
100
            fmt.Printf("Block: %d\n", m.GetBlock().GetBlockHeight().GetBlockHeight())
101
        case m.GetBlockMeta() != nil:
102
            fmt.Printf("BlockMeta: %d\n", m.GetBlockMeta().GetBlockHeight().GetBlockHeight())
103
        case m.GetTransaction() != nil:
104
            fmt.Printf("Transaction: %s\n", base58.Encode(m.GetTransaction().GetTransaction().GetSignature()))
105
        case m.GetSlot() != nil:
106
            fmt.Printf("Slot: %d\n", m.GetSlot().GetSlot())
107
        }
108
    }
109
}
110

1
import Client, { CommitmentLevel, SubscribeRequest, SubscribeUpdate, SubscribeUpdateTransaction } from "@triton-one/yellowstone-grpc";
2

3
// Quicknode endpoints consist of two crucial components: the endpoint name and the corresponding token
4
// For eg: QN Endpoint: https://docs-demo.solana-mainnet.quiknode.pro/abcde123456789
5
// endpoint will be: https://docs-demo.solana-mainnet.quiknode.pro:443  {443 is the port number for gRPC}
6
// token will be : abcde123456789
7

8
const ENDPOINT = "https://YOUR_QN_ENDPOINT:443";
9
const TOKEN = "YOUR_TOKEN_NUMBER";
10

11
async function main() {
12
    const client = new Client(ENDPOINT, TOKEN, {
13
        grpcDefaultCompressionAlgorithm: 0, // 0 = gzip, 1 = zstd
14
    });
15
    await client.connect();
16

17
    const commitment = CommitmentLevel.CONFIRMED;
18

19
    try {
20
        const stream = await client.subscribe();
21

22
        // Set up error and end handlers
23
        stream.on("error", (error) => {
24
            console.error("Stream error:", error);
25
            stream.end();
26
        });
27

28
        stream.on("end", () => {
29
            console.log("Stream ended");
30
        });
31

32
        // Handle incoming data
33
        stream.on("data", (data: SubscribeUpdate) => {
34
            handleSubscribeUpdate(data);
35
        });
36

37
        // Create subscription request
38
        const request: SubscribeRequest = {
39
            slots: { client: { filterByCommitment: true } },
40
            transactions: {
41
                client: {
42
                    vote: false,
43
                    failed: false,
44
                    signature: undefined,
45
                    accountInclude: [],
46
                    accountExclude: [],
47
                    accountRequired: [],
48
                },
49
            },
50
            commitment: commitment,
51
            accounts: {},
52
            transactionsStatus: {},
53
            entry: {},
54
            blocks: {},
55
            blocksMeta: {},
56
            accountsDataSlice: [],
57
            ping: undefined,
58
        };
59

60
        // Send subscription request
61
        await new Promise<void>((resolve, reject) => {
62
            stream.write(request, (err: Error | null | undefined) => {
63
                if (err) {
64
                    reject(err);
65
                } else {
66
                    resolve();
67
                }
68
            });
69
        });
70

71
        console.log("Subscription started. Waiting for events...");
72

73
        // Keep the script running
74
        await new Promise(() => {});
75

76
    } catch (error) {
77
        console.error("Error in subscription process:", error);
78
    }
79
}
80

81
function handleSubscribeUpdate(data: SubscribeUpdate) {
82
    if (data.slot) {
83
        console.log("Slot update:", data.slot);
84
    } else if (data.transaction) {
85
        const transaction = data.transaction as SubscribeUpdateTransaction;
86
        if (transaction && transaction.transaction) {
87
            console.log("Transaction update:", {
88
                signature: Buffer.from(transaction.transaction.signature).toString('base64'),
89
                slot: transaction.slot,
90
            });
91
        }
92
    } else {
93
        console.log("Other update:", data);
94
    }
95
}
96

97
main()
98
    .catch((err) => {
99
        console.error("Unhandled error:", err);
100
        process.exit(1);
101
    });
102

1
import Client, { CommitmentLevel, SubscribeRequest, SubscribeUpdate, SubscribeUpdateTransaction } from "@triton-one/yellowstone-grpc";
2

3
// Quicknode endpoints consist of two crucial components: the endpoint name and the corresponding token
4
// For eg: QN Endpoint: https://docs-demo.solana-mainnet.quiknode.pro/abcde123456789
5
// endpoint will be: https://docs-demo.solana-mainnet.quiknode.pro:443  {443 is the port number for gRPC}
6
// token will be : abcde123456789
7

8
const ENDPOINT = "https://YOUR_QN_ENDPOINT:443";
9
const TOKEN = "YOUR_TOKEN_NUMBER";
10

11
async function main() {
12
    const client = new Client(ENDPOINT, TOKEN, {
13
        grpcDefaultCompressionAlgorithm: 0, // 0 = gzip, 1 = zstd
14
    });
15
    await client.connect();
16

17
    const commitment = CommitmentLevel.CONFIRMED;
18

19
    try {
20
        const stream = await client.subscribe();
21

22
        // Set up error and end handlers
23
        stream.on("error", (error) => {
24
            console.error("Stream error:", error);
25
            stream.end();
26
        });
27

28
        stream.on("end", () => {
29
            console.log("Stream ended");
30
        });
31

32
        // Handle incoming data
33
        stream.on("data", (data: SubscribeUpdate) => {
34
            handleSubscribeUpdate(data);
35
        });
36

37
        // Create subscription request
38
        const request: SubscribeRequest = {
39
            slots: { client: { filterByCommitment: true } },
40
            transactions: {
41
                client: {
42
                    vote: false,
43
                    failed: false,
44
                    signature: undefined,
45
                    accountInclude: [],
46
                    accountExclude: [],
47
                    accountRequired: [],
48
                },
49
            },
50
            commitment: commitment,
51
            accounts: {},
52
            transactionsStatus: {},
53
            entry: {},
54
            blocks: {},
55
            blocksMeta: {},
56
            accountsDataSlice: [],
57
            ping: undefined,
58
        };
59

60
        // Send subscription request
61
        await new Promise<void>((resolve, reject) => {
62
            stream.write(request, (err: Error | null | undefined) => {
63
                if (err) {
64
                    reject(err);
65
                } else {
66
                    resolve();
67
                }
68
            });
69
        });
70

71
        console.log("Subscription started. Waiting for events...");
72

73
        // Keep the script running
74
        await new Promise(() => {});
75

76
    } catch (error) {
77
        console.error("Error in subscription process:", error);
78
    }
79
}
80

81
function handleSubscribeUpdate(data: SubscribeUpdate) {
82
    if (data.slot) {
83
        console.log("Slot update:", data.slot);
84
    } else if (data.transaction) {
85
        const transaction = data.transaction as SubscribeUpdateTransaction;
86
        if (transaction && transaction.transaction) {
87
            console.log("Transaction update:", {
88
                signature: Buffer.from(transaction.transaction.signature).toString('base64'),
89
                slot: transaction.slot,
90
            });
91
        }
92
    } else {
93
        console.log("Other update:", data);
94
    }
95
}
96

97
main()
98
    .catch((err) => {
99
        console.error("Unhandled error:", err);
100
        process.exit(1);
101
    });
102

Don't have an account yet?

Create your Quicknode endpoint in seconds and start building

Get started for free

subscribe gRPC Method - Solana gRPC

Loading...

Parameters

Returns