Ping gRPC Method

Please note that this method is metered based on data consumption at 0.1 MB = 10 API credits.

Parameters

count

integer

Loading...

Returns

response

integer

Loading...

Request

1
package main
2

3
import (
4
	"context"
5
	"crypto/tls"
6
	"fmt"
7
	"log"
8

9
	"google.golang.org/grpc"
10
	"google.golang.org/grpc/credentials"
11
	"google.golang.org/grpc/metadata"
12

13
	pb "hyperliquid-grpc-go/pb"
14
)
15

16
const (
17
	// Using Quicknode endpoint
18
	grpcEndpoint = "your-endpoint.hype-mainnet.quiknode.pro:10000"
19
	authToken    = "your-auth-token"
20
)
21

22
// Create gRPC connection with TLS
23
func createConnection() (*grpc.ClientConn, error) {
24
	tlsConfig := &tls.Config{
25
		InsecureSkipVerify: false, // Set to true only for testing
26
	}
27
	creds := credentials.NewTLS(tlsConfig)
28

29
	conn, err := grpc.Dial(
30
		grpcEndpoint,
31
		grpc.WithTransportCredentials(creds),
32
		grpc.WithDefaultCallOptions(
33
			grpc.MaxCallRecvMsgSize(100*1024*1024), // 100MB
34
		),
35
	)
36

37
	return conn, err
38
}
39

40
// Create context with auth metadata
41
func createContext() context.Context {
42
	md := metadata.Pairs("x-token", authToken)
43
	return metadata.NewOutgoingContext(context.Background(), md)
44
}
45

46

47
// Test connectivity
48
func pingTest(client pb.StreamingClient) error {
49
	ctx := createContext()
50

51
	resp, err := client.Ping(ctx, &pb.PingRequest{Count: 1})
52
	if err != nil {
53
		return fmt.Errorf("ping failed: %v", err)
54
	}
55

56
	log.Printf("✅ Ping successful: %+v", resp)
57
	return nil
58
}
59

60

61
func main() {
62
	// Create connection
63
	conn, err := createConnection()
64
	if err != nil {
65
		log.Fatalf("❌ Failed to connect: %v", err)
66
	}
67
	defer conn.Close()
68

69
	// Create client
70
	client := pb.NewStreamingClient(conn)
71

72
	// Test connectivity
73
	fmt.Printf("Testing connection to: %s\n", grpcEndpoint)
74
	if err := pingTest(client); err != nil {
75
		log.Fatalf("❌ Ping test failed: %v", err)
76
	}
77

78
	fmt.Println("✅ Connection test completed successfully!")
79
}

1
package main
2

3
import (
4
	"context"
5
	"crypto/tls"
6
	"fmt"
7
	"log"
8

9
	"google.golang.org/grpc"
10
	"google.golang.org/grpc/credentials"
11
	"google.golang.org/grpc/metadata"
12

13
	pb "hyperliquid-grpc-go/pb"
14
)
15

16
const (
17
	// Using Quicknode endpoint
18
	grpcEndpoint = "your-endpoint.hype-mainnet.quiknode.pro:10000"
19
	authToken    = "your-auth-token"
20
)
21

22
// Create gRPC connection with TLS
23
func createConnection() (*grpc.ClientConn, error) {
24
	tlsConfig := &tls.Config{
25
		InsecureSkipVerify: false, // Set to true only for testing
26
	}
27
	creds := credentials.NewTLS(tlsConfig)
28

29
	conn, err := grpc.Dial(
30
		grpcEndpoint,
31
		grpc.WithTransportCredentials(creds),
32
		grpc.WithDefaultCallOptions(
33
			grpc.MaxCallRecvMsgSize(100*1024*1024), // 100MB
34
		),
35
	)
36

37
	return conn, err
38
}
39

40
// Create context with auth metadata
41
func createContext() context.Context {
42
	md := metadata.Pairs("x-token", authToken)
43
	return metadata.NewOutgoingContext(context.Background(), md)
44
}
45

46

47
// Test connectivity
48
func pingTest(client pb.StreamingClient) error {
49
	ctx := createContext()
50

51
	resp, err := client.Ping(ctx, &pb.PingRequest{Count: 1})
52
	if err != nil {
53
		return fmt.Errorf("ping failed: %v", err)
54
	}
55

56
	log.Printf("✅ Ping successful: %+v", resp)
57
	return nil
58
}
59

60

61
func main() {
62
	// Create connection
63
	conn, err := createConnection()
64
	if err != nil {
65
		log.Fatalf("❌ Failed to connect: %v", err)
66
	}
67
	defer conn.Close()
68

69
	// Create client
70
	client := pb.NewStreamingClient(conn)
71

72
	// Test connectivity
73
	fmt.Printf("Testing connection to: %s\n", grpcEndpoint)
74
	if err := pingTest(client); err != nil {
75
		log.Fatalf("❌ Ping test failed: %v", err)
76
	}
77

78
	fmt.Println("✅ Connection test completed successfully!")
79
}

1
const grpc = require('@grpc/grpc-js');
2
const protoLoader = require('@grpc/proto-loader');
3
const path = require('path');
4

5
// Configuration
6
const GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000';
7
const AUTH_TOKEN = 'your-auth-token';
8

9
// Load proto file
10
const packageDefinition = protoLoader.loadSync(
11
  path.join(__dirname, 'proto/streaming.proto'),
12
  {
13
    keepCase: true,
14
    longs: String,
15
    enums: String,
16
    defaults: true,
17
    oneofs: true,
18
  }
19
);
20

21
const hyperliquidProto = grpc.loadPackageDefinition(packageDefinition).hyperliquid;
22

23
// Create gRPC client with TLS
24
function createClient() {
25
  const credentials = grpc.credentials.createSsl();
26

27
  const client = new hyperliquidProto.Streaming(
28
    GRPC_ENDPOINT,
29
    credentials,
30
    {
31
      'grpc.max_receive_message_length': 100 * 1024 * 1024, // 100MB
32
    }
33
  );
34

35
  return client;
36
}
37

38
// Create metadata with auth token
39
function createMetadata() {
40
  const metadata = new grpc.Metadata();
41
  metadata.add('x-token', AUTH_TOKEN);
42
  return metadata;
43
}
44

45
// Test connectivity with ping
46
function testPing(client) {
47
  return new Promise((resolve, reject) => {
48
    const metadata = createMetadata();
49

50
    client.Ping({ count: 1 }, metadata, (error, response) => {
51
      if (error) {
52
        reject(new Error(`Ping failed: ${error.message}`));
53
        return;
54
      }
55

56
      console.log('✅ Ping successful:', response);
57
      resolve(response);
58
    });
59
  });
60
}
61

62
// Main function
63
async function main() {
64
  try {
65
    console.log(`Testing connection to: ${GRPC_ENDPOINT}`);
66

67
    // Create client
68
    const client = createClient();
69

70
    // Test connectivity
71
    await testPing(client);
72

73
    console.log('✅ Connection test completed successfully!');
74

75
    // Close the client
76
    client.close();
77

78
  } catch (error) {
79
    console.error('❌ Error:', error.message);
80
    process.exit(1);
81
  }
82
}
83

84
// Run the application
85
main();

1
const grpc = require('@grpc/grpc-js');
2
const protoLoader = require('@grpc/proto-loader');
3
const path = require('path');
4

5
// Configuration
6
const GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000';
7
const AUTH_TOKEN = 'your-auth-token';
8

9
// Load proto file
10
const packageDefinition = protoLoader.loadSync(
11
  path.join(__dirname, 'proto/streaming.proto'),
12
  {
13
    keepCase: true,
14
    longs: String,
15
    enums: String,
16
    defaults: true,
17
    oneofs: true,
18
  }
19
);
20

21
const hyperliquidProto = grpc.loadPackageDefinition(packageDefinition).hyperliquid;
22

23
// Create gRPC client with TLS
24
function createClient() {
25
  const credentials = grpc.credentials.createSsl();
26

27
  const client = new hyperliquidProto.Streaming(
28
    GRPC_ENDPOINT,
29
    credentials,
30
    {
31
      'grpc.max_receive_message_length': 100 * 1024 * 1024, // 100MB
32
    }
33
  );
34

35
  return client;
36
}
37

38
// Create metadata with auth token
39
function createMetadata() {
40
  const metadata = new grpc.Metadata();
41
  metadata.add('x-token', AUTH_TOKEN);
42
  return metadata;
43
}
44

45
// Test connectivity with ping
46
function testPing(client) {
47
  return new Promise((resolve, reject) => {
48
    const metadata = createMetadata();
49

50
    client.Ping({ count: 1 }, metadata, (error, response) => {
51
      if (error) {
52
        reject(new Error(`Ping failed: ${error.message}`));
53
        return;
54
      }
55

56
      console.log('✅ Ping successful:', response);
57
      resolve(response);
58
    });
59
  });
60
}
61

62
// Main function
63
async function main() {
64
  try {
65
    console.log(`Testing connection to: ${GRPC_ENDPOINT}`);
66

67
    // Create client
68
    const client = createClient();
69

70
    // Test connectivity
71
    await testPing(client);
72

73
    console.log('✅ Connection test completed successfully!');
74

75
    // Close the client
76
    client.close();
77

78
  } catch (error) {
79
    console.error('❌ Error:', error.message);
80
    process.exit(1);
81
  }
82
}
83

84
// Run the application
85
main();

1
import grpc
2
import sys
3
from pb import streaming_pb2, streaming_pb2_grpc
4

5
# Configuration
6
GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000'
7
AUTH_TOKEN = 'your-auth-token'
8

9
def create_channel():
10
    """Create gRPC channel with TLS"""
11
    credentials = grpc.ssl_channel_credentials()
12
    channel = grpc.secure_channel(
13
        GRPC_ENDPOINT,
14
        credentials,
15
        options=[
16
            ('grpc.max_receive_message_length', 100 * 1024 * 1024),  # 100MB
17
            ('grpc.max_send_message_length', 100 * 1024 * 1024),     # 100MB
18
        ]
19
    )
20
    return channel
21

22
def create_metadata():
23
    """Create metadata with auth token"""
24
    return [('x-token', AUTH_TOKEN)]
25

26
def test_ping(stub):
27
    """Test connectivity with ping"""
28
    try:
29
        metadata = create_metadata()
30
        request = streaming_pb2.PingRequest(count=1)
31

32
        response = stub.Ping(request, metadata=metadata)
33
        print(f"✅ Ping successful: {response}")
34
        return True
35
    except grpc.RpcError as e:
36
        print(f"❌ Ping failed: {e.details()}")
37
        return False
38

39
def main():
40
    """Main function"""
41
    try:
42
        print(f"Testing connection to: {GRPC_ENDPOINT}")
43

44
        # Create channel and stub
45
        channel = create_channel()
46
        streaming_stub = streaming_pb2_grpc.StreamingStub(channel)
47

48
        # Test connectivity
49
        if test_ping(streaming_stub):
50
            print("✅ Connection test completed successfully!")
51
        else:
52
            print("❌ Connection test failed!")
53

54
        # Close channel
55
        channel.close()
56

57
    except KeyboardInterrupt:
58
        print("\n👋 Goodbye!")
59
    except Exception as e:
60
        print(f"❌ Error: {e}")
61
        sys.exit(1)
62

63
if __name__ == "__main__":
64
    main()

1
import grpc
2
import sys
3
from pb import streaming_pb2, streaming_pb2_grpc
4

5
# Configuration
6
GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000'
7
AUTH_TOKEN = 'your-auth-token'
8

9
def create_channel():
10
    """Create gRPC channel with TLS"""
11
    credentials = grpc.ssl_channel_credentials()
12
    channel = grpc.secure_channel(
13
        GRPC_ENDPOINT,
14
        credentials,
15
        options=[
16
            ('grpc.max_receive_message_length', 100 * 1024 * 1024),  # 100MB
17
            ('grpc.max_send_message_length', 100 * 1024 * 1024),     # 100MB
18
        ]
19
    )
20
    return channel
21

22
def create_metadata():
23
    """Create metadata with auth token"""
24
    return [('x-token', AUTH_TOKEN)]
25

26
def test_ping(stub):
27
    """Test connectivity with ping"""
28
    try:
29
        metadata = create_metadata()
30
        request = streaming_pb2.PingRequest(count=1)
31

32
        response = stub.Ping(request, metadata=metadata)
33
        print(f"✅ Ping successful: {response}")
34
        return True
35
    except grpc.RpcError as e:
36
        print(f"❌ Ping failed: {e.details()}")
37
        return False
38

39
def main():
40
    """Main function"""
41
    try:
42
        print(f"Testing connection to: {GRPC_ENDPOINT}")
43

44
        # Create channel and stub
45
        channel = create_channel()
46
        streaming_stub = streaming_pb2_grpc.StreamingStub(channel)
47

48
        # Test connectivity
49
        if test_ping(streaming_stub):
50
            print("✅ Connection test completed successfully!")
51
        else:
52
            print("❌ Connection test failed!")
53

54
        # Close channel
55
        channel.close()
56

57
    except KeyboardInterrupt:
58
        print("\n👋 Goodbye!")
59
    except Exception as e:
60
        print(f"❌ Error: {e}")
61
        sys.exit(1)
62

63
if __name__ == "__main__":
64
    main()

Don't have an account yet?

Create your Quicknode endpoint in seconds and start building

Get started for free