StreamBlocks gRPC Method

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

Paramètres

horodatage

entier

Chargement...

Renvoie

flux

stream<Block>

Chargement...

data_json

chaîne de caractères

Chargement...

abci_block.round

entier

Chargement...

abci_block.parent_round

entier

Chargement...

abci_block.time

chaîne de caractères

Chargement...

abci_block.proposer

chaîne de caractères

Chargement...

abci_block.hardfork

objet

Chargement...

abci_block.signed_action_bundles

tableau

Chargement...

resps

objet

Chargement...

Requête

1
package main
2

3
import (
4
	"context"
5
	"crypto/tls"
6
	"encoding/json"
7
	"fmt"
8
	"io"
9
	"log"
10
	"time"
11

12
	"google.golang.org/grpc"
13
	"google.golang.org/grpc/credentials"
14
	"google.golang.org/grpc/metadata"
15

16
	pb "hyperliquid-grpc-go/pb"
17
)
18

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

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

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

40
	return conn, err
41
}
42

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

49

50
// Stream blocks
51
func streamBlocks(client pb.BlockStreamingClient) error {
52
	ctx := createContext()
53

54
	stream, err := client.StreamBlocks(ctx, &pb.Timestamp{
55
		Timestamp: time.Now().UnixMilli(),
56
	})
57
	if err != nil {
58
		return fmt.Errorf("failed to stream blocks: %v", err)
59
	}
60

61
	log.Println("🔄 Starting blocks stream...")
62

63
	for {
64
		block, err := stream.Recv()
65
		if err == io.EOF {
66
			log.Println("Block stream ended")
67
			break
68
		}
69
		if err != nil {
70
			return fmt.Errorf("receive error: %v", err)
71
		}
72

73
		var blockData map[string]interface{}
74
		if err := json.Unmarshal([]byte(block.DataJson), &blockData); err != nil {
75
			log.Printf("⚠️  Failed to parse block: %v", err)
76
			continue
77
		}
78

79
		if abciBlock, ok := blockData["abci_block"].(map[string]interface{}); ok {
80
			if round, ok := abciBlock["round"].(float64); ok {
81
				log.Printf("🧱 Received block round: %.0f", round)
82
			}
83
		}
84
	}
85

86
	return nil
87
}
88

89

90
// Interactive menu
91
func runInteractiveMenu(conn *grpc.ClientConn) {
92
	blockClient := pb.NewBlockStreamingClient(conn)
93

94
	fmt.Println("\n🎉 Connected successfully!")
95
	fmt.Println("\nAvailable stream:")
96
	fmt.Println("1. Stream blocks")
97
	fmt.Println("2. Exit")
98

99
	for {
100
		fmt.Print("\nSelect option (1-2): ")
101
		var choice string
102
		fmt.Scanln(&choice)
103

104
		switch choice {
105
		case "1":
106
			if err := streamBlocks(blockClient); err != nil {
107
				log.Printf("❌ Block stream error: %v", err)
108
			}
109
		case "2":
110
			fmt.Println("👋 Goodbye!")
111
			return
112
		default:
113
			fmt.Println("❌ Invalid choice. Please select 1-2.")
114
		}
115
	}
116
}
117

118
func main() {
119
	// Create connection
120
	conn, err := createConnection()
121
	if err != nil {
122
		log.Fatalf("❌ Failed to connect: %v", err)
123
	}
124
	defer conn.Close()
125

126
	fmt.Printf("Connected to: %s\n", grpcEndpoint)
127

128
	// Run interactive menu
129
	runInteractiveMenu(conn)
130
}

1
package main
2

3
import (
4
	"context"
5
	"crypto/tls"
6
	"encoding/json"
7
	"fmt"
8
	"io"
9
	"log"
10
	"time"
11

12
	"google.golang.org/grpc"
13
	"google.golang.org/grpc/credentials"
14
	"google.golang.org/grpc/metadata"
15

16
	pb "hyperliquid-grpc-go/pb"
17
)
18

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

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

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

40
	return conn, err
41
}
42

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

49

50
// Stream blocks
51
func streamBlocks(client pb.BlockStreamingClient) error {
52
	ctx := createContext()
53

54
	stream, err := client.StreamBlocks(ctx, &pb.Timestamp{
55
		Timestamp: time.Now().UnixMilli(),
56
	})
57
	if err != nil {
58
		return fmt.Errorf("failed to stream blocks: %v", err)
59
	}
60

61
	log.Println("🔄 Starting blocks stream...")
62

63
	for {
64
		block, err := stream.Recv()
65
		if err == io.EOF {
66
			log.Println("Block stream ended")
67
			break
68
		}
69
		if err != nil {
70
			return fmt.Errorf("receive error: %v", err)
71
		}
72

73
		var blockData map[string]interface{}
74
		if err := json.Unmarshal([]byte(block.DataJson), &blockData); err != nil {
75
			log.Printf("⚠️  Failed to parse block: %v", err)
76
			continue
77
		}
78

79
		if abciBlock, ok := blockData["abci_block"].(map[string]interface{}); ok {
80
			if round, ok := abciBlock["round"].(float64); ok {
81
				log.Printf("🧱 Received block round: %.0f", round)
82
			}
83
		}
84
	}
85

86
	return nil
87
}
88

89

90
// Interactive menu
91
func runInteractiveMenu(conn *grpc.ClientConn) {
92
	blockClient := pb.NewBlockStreamingClient(conn)
93

94
	fmt.Println("\n🎉 Connected successfully!")
95
	fmt.Println("\nAvailable stream:")
96
	fmt.Println("1. Stream blocks")
97
	fmt.Println("2. Exit")
98

99
	for {
100
		fmt.Print("\nSelect option (1-2): ")
101
		var choice string
102
		fmt.Scanln(&choice)
103

104
		switch choice {
105
		case "1":
106
			if err := streamBlocks(blockClient); err != nil {
107
				log.Printf("❌ Block stream error: %v", err)
108
			}
109
		case "2":
110
			fmt.Println("👋 Goodbye!")
111
			return
112
		default:
113
			fmt.Println("❌ Invalid choice. Please select 1-2.")
114
		}
115
	}
116
}
117

118
func main() {
119
	// Create connection
120
	conn, err := createConnection()
121
	if err != nil {
122
		log.Fatalf("❌ Failed to connect: %v", err)
123
	}
124
	defer conn.Close()
125

126
	fmt.Printf("Connected to: %s\n", grpcEndpoint)
127

128
	// Run interactive menu
129
	runInteractiveMenu(conn)
130
}

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
// Stream blocks (raw HyperCore data)
63
function streamBlocks(blockClient) {
64
  return new Promise((resolve, reject) => {
65
    const metadata = createMetadata();
66

67
    const stream = blockClient.StreamBlocks({
68
      timestamp: Date.now()
69
    }, metadata);
70

71
    stream.on('data', (block) => {
72
      try {
73
        const blockData = JSON.parse(block.data_json);
74

75
        if (blockData.abci_block && blockData.abci_block.round) {
76
          console.log(`🧱 Received block round: ${blockData.abci_block.round}`);
77
        }
78
        
79
        // Pretty print the full block data (optional - can be very verbose)
80
        // console.log(JSON.stringify(blockData, null, 2));
81

82
      } catch (error) {
83
        console.log('⚠️  Failed to parse block:', error.message);
84
      }
85
    });
86

87
    stream.on('error', (error) => {
88
      console.error('❌ Stream error:', error.message);
89
      reject(error);
90
    });
91

92
    stream.on('end', () => {
93
      console.log('Block stream ended');
94
      resolve();
95
    });
96

97
    // Clean up on exit
98
    const cleanup = () => {
99
      stream.cancel();
100
    };
101

102
    process.on('SIGINT', cleanup);
103
    process.on('SIGTERM', cleanup);
104

105
    console.log('🔄 Starting blocks stream...');
106
  });
107
}
108

109
// Interactive menu
110
function showMenu() {
111
  console.log('\n🎉 Connected successfully!');
112
  console.log('\nAvailable options:');
113
  console.log('1. Stream blocks');
114
  console.log('2. Test ping');
115
  console.log('3. Exit');
116

117
  const readline = require('readline');
118
  const rl = readline.createInterface({
119
    input: process.stdin,
120
    output: process.stdout
121
  });
122

123
  return new Promise((resolve) => {
124
    rl.question('\nSelect option (1-3): ', (choice) => {
125
      rl.close();
126
      resolve(choice);
127
    });
128
  });
129
}
130

131
// Main function
132
async function main() {
133
  essayer {
134
    console.log(`Testing connection to: ${GRPC_ENDPOINT}`);
135

136
    // Create client
137
    const client = createClient();
138

139
    // Test initial connectivity
140
    await testPing(client);
141

142
    // Create block streaming client
143
    const blockClient = new hyperliquidProto.BlockStreaming(
144
      GRPC_ENDPOINT,
145
      grpc.credentials.createSsl(),
146
      {
147
        'grpc.max_receive_message_length': 100 * 1024 * 1024, // 100MB
148
      }
149
    );
150

151
    // Show interactive menu
152
    while (true) {
153
      const choice = await showMenu();
154

155
      switch (choice) {
156
        case '1':
157
          await streamBlocks(blockClient);
158
          break;
159
        case '2':
160
          await testPing(client);
161
          break;
162
        case '3':
163
          console.log('👋 Goodbye!');
164
          client.close();
165
          blockClient.close();
166
          return;
167
        default:
168
          console.log('❌ Invalid choice. Please select 1-3.');
169
      }
170
    }
171

172
  } catch (erreur) {
173
    console.error('❌ Error:', error.message);
174
    process.exit(1);
175
  }
176
}
177

178
// Run the application
179
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
// Stream blocks (raw HyperCore data)
63
function streamBlocks(blockClient) {
64
  return new Promise((resolve, reject) => {
65
    const metadata = createMetadata();
66

67
    const stream = blockClient.StreamBlocks({
68
      timestamp: Date.now()
69
    }, metadata);
70

71
    stream.on('data', (block) => {
72
      try {
73
        const blockData = JSON.parse(block.data_json);
74

75
        if (blockData.abci_block && blockData.abci_block.round) {
76
          console.log(`🧱 Received block round: ${blockData.abci_block.round}`);
77
        }
78
        
79
        // Pretty print the full block data (optional - can be very verbose)
80
        // console.log(JSON.stringify(blockData, null, 2));
81

82
      } catch (error) {
83
        console.log('⚠️  Failed to parse block:', error.message);
84
      }
85
    });
86

87
    stream.on('error', (error) => {
88
      console.error('❌ Stream error:', error.message);
89
      reject(error);
90
    });
91

92
    stream.on('end', () => {
93
      console.log('Block stream ended');
94
      resolve();
95
    });
96

97
    // Clean up on exit
98
    const cleanup = () => {
99
      stream.cancel();
100
    };
101

102
    process.on('SIGINT', cleanup);
103
    process.on('SIGTERM', cleanup);
104

105
    console.log('🔄 Starting blocks stream...');
106
  });
107
}
108

109
// Interactive menu
110
function showMenu() {
111
  console.log('\n🎉 Connected successfully!');
112
  console.log('\nAvailable options:');
113
  console.log('1. Stream blocks');
114
  console.log('2. Test ping');
115
  console.log('3. Exit');
116

117
  const readline = require('readline');
118
  const rl = readline.createInterface({
119
    input: process.stdin,
120
    output: process.stdout
121
  });
122

123
  return new Promise((resolve) => {
124
    rl.question('\nSelect option (1-3): ', (choice) => {
125
      rl.close();
126
      resolve(choice);
127
    });
128
  });
129
}
130

131
// Main function
132
async function main() {
133
  essayer {
134
    console.log(`Testing connection to: ${GRPC_ENDPOINT}`);
135

136
    // Create client
137
    const client = createClient();
138

139
    // Test initial connectivity
140
    await testPing(client);
141

142
    // Create block streaming client
143
    const blockClient = new hyperliquidProto.BlockStreaming(
144
      GRPC_ENDPOINT,
145
      grpc.credentials.createSsl(),
146
      {
147
        'grpc.max_receive_message_length': 100 * 1024 * 1024, // 100MB
148
      }
149
    );
150

151
    // Show interactive menu
152
    while (true) {
153
      const choice = await showMenu();
154

155
      switch (choice) {
156
        case '1':
157
          await streamBlocks(blockClient);
158
          break;
159
        case '2':
160
          await testPing(client);
161
          break;
162
        case '3':
163
          console.log('👋 Goodbye!');
164
          client.close();
165
          blockClient.close();
166
          return;
167
        default:
168
          console.log('❌ Invalid choice. Please select 1-3.');
169
      }
170
    }
171

172
  } catch (erreur) {
173
    console.error('❌ Error:', error.message);
174
    process.exit(1);
175
  }
176
}
177

178
// Run the application
179
main();

1
import grpc
2
import json
3
import time
4
import signal
5
import sys
6
import threading
7
from pb import streaming_pb2, streaming_pb2_grpc
8

9
# Configuration
10
GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000'
11
AUTH_TOKEN = 'your-auth-token'
12

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

26
def create_metadata():
27
    """Create metadata with auth token"""
28
    return [('x-token', AUTH_TOKEN)]
29

30
def test_ping(stub):
31
    """Test connectivity with ping"""
32
    try:
33
        metadata = create_metadata()
34
        request = streaming_pb2.PingRequest(count=1)
35

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

43
def stream_blocks(stub):
44
    """Stream blocks (raw HyperCore data)"""
45
    try:
46
        metadata = create_metadata()
47
        request = streaming_pb2.Timestamp(timestamp=int(time.time() * 1000))
48

49
        print("🔄 Starting blocks stream...")
50

51
        # Create stream
52
        stream = stub.StreamBlocks(request, metadata=metadata)
53

54
        # Handle stream data
55
        for block in stream:
56
            try:
57
                block_data = json.loads(block.data_json)
58

59
                if 'abci_block' in block_data and 'round' in block_data['abci_block']:
60
                    block_round = block_data['abci_block']['round']
61
                    print(f"🧱 Received block round: {block_round}")
62

63
                # Pretty print the full block data (optional - can be very verbose)
64
                # print(json.dumps(block_data, indent=2))
65

66
            except json.JSONDecodeError as e:
67
                print(f"⚠️  Failed to parse block: {e}")
68
            except KeyboardInterrupt:
69
                print("\n⏹️  Stream interrupted by user")
70
                break
71

72
    except grpc.RpcError as e:
73
        print(f"❌ Stream error: {e.details()}")
74
    except KeyboardInterrupt:
75
        print("\n⏹️  Stream interrupted by user")
76

77
def show_menu():
78
    """Display interactive menu"""
79
    print("\n🎉 Connected successfully!")
80
    print("\nAvailable options:")
81
    print("1. Stream blocks")
82
    print("2. Test ping")
83
    print("3. Exit")
84

85
    while True:
86
        try:
87
            choice = input("\nSelect option (1-3): ").strip()
88
            if choice in ['1', '2', '3']:
89
                return choice
90
            else:
91
                print("❌ Invalid choice. Please select 1-3.")
92
        except KeyboardInterrupt:
93
            return '3'
94

95
def main():
96
    """Main function"""
97
    try:
98
        print(f"Testing connection to: {GRPC_ENDPOINT}")
99

100
        # Create channel and stubs
101
        channel = create_channel()
102
        streaming_stub = streaming_pb2_grpc.StreamingStub(channel)
103
        block_streaming_stub = streaming_pb2_grpc.BlockStreamingStub(channel)
104

105
        # Test initial connectivity
106
        if not test_ping(streaming_stub):
107
            print("❌ Connection test failed!")
108
            return
109

110
        # Interactive menu loop
111
        while True:
112
            choice = show_menu()
113

114
            if choice == '1':
115
                stream_blocks(block_streaming_stub)
116
            elif choice == '2':
117
                test_ping(streaming_stub)
118
            elif choice == '3':
119
                print("👋 Goodbye!")
120
                break
121

122
        # Close channel
123
        channel.close()
124

125
    except KeyboardInterrupt:
126
        print("\n👋 Goodbye!")
127
    except Exception as e:
128
        print(f"❌ Error: {e}")
129
        sys.exit(1)
130

131
if __name__ == "__main__":
132
    main()

1
import grpc
2
import json
3
import time
4
import signal
5
import sys
6
import threading
7
from pb import streaming_pb2, streaming_pb2_grpc
8

9
# Configuration
10
GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000'
11
AUTH_TOKEN = 'your-auth-token'
12

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

26
def create_metadata():
27
    """Create metadata with auth token"""
28
    return [('x-token', AUTH_TOKEN)]
29

30
def test_ping(stub):
31
    """Test connectivity with ping"""
32
    try:
33
        metadata = create_metadata()
34
        request = streaming_pb2.PingRequest(count=1)
35

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

43
def stream_blocks(stub):
44
    """Stream blocks (raw HyperCore data)"""
45
    try:
46
        metadata = create_metadata()
47
        request = streaming_pb2.Timestamp(timestamp=int(time.time() * 1000))
48

49
        print("🔄 Starting blocks stream...")
50

51
        # Create stream
52
        stream = stub.StreamBlocks(request, metadata=metadata)
53

54
        # Handle stream data
55
        for block in stream:
56
            try:
57
                block_data = json.loads(block.data_json)
58

59
                if 'abci_block' in block_data and 'round' in block_data['abci_block']:
60
                    block_round = block_data['abci_block']['round']
61
                    print(f"🧱 Received block round: {block_round}")
62

63
                # Pretty print the full block data (optional - can be very verbose)
64
                # print(json.dumps(block_data, indent=2))
65

66
            except json.JSONDecodeError as e:
67
                print(f"⚠️  Failed to parse block: {e}")
68
            except KeyboardInterrupt:
69
                print("\n⏹️  Stream interrupted by user")
70
                break
71

72
    except grpc.RpcError as e:
73
        print(f"❌ Stream error: {e.details()}")
74
    except KeyboardInterrupt:
75
        print("\n⏹️  Stream interrupted by user")
76

77
def show_menu():
78
    """Display interactive menu"""
79
    print("\n🎉 Connected successfully!")
80
    print("\nAvailable options:")
81
    print("1. Stream blocks")
82
    print("2. Test ping")
83
    print("3. Exit")
84

85
    while True:
86
        try:
87
            choice = input("\nSelect option (1-3): ").strip()
88
            if choice in ['1', '2', '3']:
89
                return choice
90
            else:
91
                print("❌ Invalid choice. Please select 1-3.")
92
        except KeyboardInterrupt:
93
            return '3'
94

95
def main():
96
    """Main function"""
97
    try:
98
        print(f"Testing connection to: {GRPC_ENDPOINT}")
99

100
        # Create channel and stubs
101
        channel = create_channel()
102
        streaming_stub = streaming_pb2_grpc.StreamingStub(channel)
103
        block_streaming_stub = streaming_pb2_grpc.BlockStreamingStub(channel)
104

105
        # Test initial connectivity
106
        if not test_ping(streaming_stub):
107
            print("❌ Connection test failed!")
108
            return
109

110
        # Interactive menu loop
111
        while True:
112
            choice = show_menu()
113

114
            if choice == '1':
115
                stream_blocks(block_streaming_stub)
116
            elif choice == '2':
117
                test_ping(streaming_stub)
118
            elif choice == '3':
119
                print("👋 Goodbye!")
120
                break
121

122
        # Close channel
123
        channel.close()
124

125
    except KeyboardInterrupt:
126
        print("\n👋 Goodbye!")
127
    except Exception as e:
128
        print(f"❌ Error: {e}")
129
        sys.exit(1)
130

131
if __name__ == "__main__":
132
    main()

Vous n'avez pas encore de compte ?

Créez votre endpoint Quicknode en quelques secondes et commencez à développer

Commencez gratuitement