StreamL4Book gRPC Method

请注意，此方法的计费是根据数据消耗量计算的，按 0.0165 MB = 10 个 API 积分 进行计费。

参数

硬币

字符串

正在加载...

退货

流

stream<L4BookUpdate>

正在加载...

snapshot

L4BookSnapshot

正在加载...

diff

L4BookDiff

正在加载...

请求

1
// StreamL4Book Example - Stream individual order data via gRPC
2
包 main
3

4
import (
5
	"上下文"
6
	"encoding/json"
7
	“flag”
8
	"fmt"
9
	"io"
10
	“日志”
11
	"数学"
12
	“字符串”
13
	“时间”
14

15
	"google.golang.grpc"
16
	"google.golang.grpc"
17
	"google.golang.grpc"
18
	"google.golang.grpc"
19
	"google.golang.grpc"
20

21
	pb "hyperliquid"
22
)
23

24
const (
25
	grpcEndpoint = "endpoint.mainnet.quiknode.pro:10000"
26
	authToken    = "您的认证令牌"
27
	maxRetries   = 10
28
	baseDelay    = 2 * time.秒
29
)
30

31
func streamL4Orderbook(coin string, maxMessages int) error {
32
	fmt.PrintlnPrintln字符串.重复("=", 60))
33
	fmt.Printf("Streaming L4 Orderbook for %s\n", coin)
34
	fmt.Println("自动重连：true")
35
	fmt.PrintlnPrintln字符串.重复("=", 60) + "\n")
36

37
	retryCount := 0
38
	totalMsgCount := 0
39

40
	for retryCount < maxRetries {
41
		creds := 凭证.NewClientTLSFromCert(nil, "")
42
		conn, err := grpc.Dial(grpcEndpoint,
43
			grpc.WithTransportCredentials(creds)，
44
			grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(100*1024*1024)))
45
		如果 err != nil {
46
			返回 fmt.Errorf("连接失败：%w", err)
47
		}
48

49
		client := pb.NewOrderBookStreamingClient(conn)
50
		ctx := 元数据.AppendToOutgoingContext(context.背景(), “x-token”, authToken)
51

52
		request := &pb.L4BookRequest{
53
			Coin: coin,
54
		}
55

56
		if retryCount > 0 {
57
			fmt.Printf("\n🔄 正在重新连接（尝试 %d/%d）...\n", retryCount+1, maxRetries)
58
		} else {
59
			fmt.Printf("正在连接到 %s...\n", grpcEndpoint)
60
		}
61

62
		stream, err := client.StreamL4Book(ctx, request)
63
		如果 err != nil {
64
			conn.关闭()
65
			返回 fmt.Errorf("启动流失败：%w", err)
66
		}
67

68
		snapshotReceived := false
69
		shouldRetry := false
70

71
		用于 {
72
			更新， err := 流.Recv()
73
			如果 err == io.EOF {
74
				换行
75
			}
76
			如果 err != nil {
77
				st， 好的 := 状态.FromError(err)
78
				如果 好的 && st.代码() == 代码.DataLoss {
79
					fmt.Printf("\n⚠️  服务器已重新初始化：%s\n", st.消息())
80
					retryCount++
81
					if retryCount < maxRetries {
82
						延迟 := baseDelay * time.Duration(数学.Pow(2, float64(重试次数-1)))
83
						fmt.Printf("⏳ 等待 %v 后再重新连接……\n", 延迟)
84
						时间.睡眠(延迟)
85
						shouldRetry = true
86
						换行
87
					} else {
88
						fmt.Printf("\n❌ 达到最大重试次数 (%d)。放弃。\n", maxRetries)
89
						conn.关闭()
90
						返回 nil
91
					}
92
				}
93
				conn.关闭()
94
				返回 fmt.Errorf("流错误：%w", err)
95
			}
96

97
			totalMsgCount++
98

99
			if snapshot := update.GetSnapshot(); snapshot != nil {
100
				snapshotReceived = true
101
				retryCount = 0 // 成功后重置
102

103
				fmt.Println("\n✓ L4 Snapshot Received!")
104
				fmt.Println(strings.Repeat("─", 60))
105
				fmt.Printf("Coin: %s\n", snapshot.Coin)
106
				fmt.Printf("Height: %d\n", snapshot.Height)
107
				fmt.Printf("Time: %d\n", snapshot.Time)
108
				fmt.Printf("Bids: %d orders\n", len(snapshot.Bids))
109
				fmt.Printf("Asks: %d orders\n", len(snapshot.Asks))
110
				fmt.Println(strings.Repeat("─", 60))
111

112
				// Sample bids
113
				if len(snapshot.Bids) > 0 {
114
					fmt.Println("\nSample Bids (first 5):")
115
					bidCount := len(snapshot.Bids)
116
					if bidCount > 5 {
117
						bidCount = 5
118
					}
119
					for i := 0; i < bidCount; i++ {
120
						order := snapshot.Bids[i]
121
						userShort := order.User
122
						if len(userShort) > 10 {
123
							userShort = userShort[:10] + "..."
124
						}
125
						fmt.Printf("  OID: %d | Price: %s | Size: %s | User: %s\n",
126
							order.Oid, order.LimitPx, order.Sz, userShort)
127
					}
128
				}
129

130
				// Sample asks
131
				if len(snapshot.Asks) > 0 {
132
					fmt.Println("\nSample Asks (first 5):")
133
					askCount := len(snapshot.Asks)
134
					if askCount > 5 {
135
						askCount = 5
136
					}
137
					for i := 0; i < askCount; i++ {
138
						order := snapshot.Asks[i]
139
						userShort := order.User
140
						if len(userShort) > 10 {
141
							userShort = userShort[:10] + "..."
142
						}
143
						fmt.Printf("  OID: %d | Price: %s | Size: %s | User: %s\n",
144
							order.Oid, order.LimitPx, order.Sz, userShort)
145
					}
146
				}
147

148
			} else if diff := update.GetDiff(); diff != nil {
149
				if !snapshotReceived {
150
					fmt.Println("\n⚠ Received diff before snapshot")
151
				}
152

153
				var diffData map[string]interface{}
154
				if err := json.Unmarshal([]byte(diff.Data), &diffData); err == nil {
155
					orderStatuses := []interface{}{}
156
					bookDiffs := []interface{}{}
157

158
					if os, ok := diffData["order_statuses"].([]interface{}); ok {
159
						orderStatuses = os
160
					}
161
					if bd, ok := diffData["book_diffs"].([]interface{}); ok {
162
						bookDiffs = bd
163
					}
164

165
					fmt.Printf("\n[Block %d] L4 Diff:\n", diff.Height)
166
					fmt.Printf("  Time: %d\n", diff.Time)
167
					fmt.Printf("  Order Statuses: %d\n", len(orderStatuses))
168
					fmt.Printf("  Book Diffs: %d\n", len(bookDiffs))
169

170
					if len(bookDiffs) > 0 && len(bookDiffs) <= 5 {
171
						pretty, _ := json.MarshalIndent(bookDiffs, "  ", "  ")
172
						fmt.Printf("  Diffs: %s\n", pretty)
173
					}
174
				}
175
			}
176

177
			if maxMessages > 0 && totalMsgCount >= maxMessages {
178
				fmt.Printf("\nReached max messages (%d), stopping...\n", maxMessages)
179
				conn.关闭()
180
				return nil
181
			}
182
		}
183

184
		conn.关闭()
185

186
		如果 !shouldRetry {
187
			换行
188
		}
189
	}
190

191
	返回 nil
192
}
193

194
func main() {
195
	coin := 标志.字符串("coin", "BTC", "要直播的币种代码")
196
	maxMessages := flag.Int("max-messages", 0, "Maximum messages (0 = unlimited)")
197

198
	flag.解析()
199

200
	fmt.Println("\n" + 字符串.重复("=", 60))
201
	fmt.Println("Hyperliquid StreamL4Book Example")
202
	fmt.Printf("Endpoint：%s\n", grpcEndpoint)
203
	fmt.PrintlnPrintln字符串.重复("=", 60))
204

205
	if err := streamL4Orderbook(*coin, *maxMessages); err != nil {
206
		log.致命(err)
207
	}
208
}
209

1
// StreamL4Book Example - Stream individual order data via gRPC
2
包 main
3

4
import (
5
	"上下文"
6
	"encoding/json"
7
	“flag”
8
	"fmt"
9
	"io"
10
	“日志”
11
	"数学"
12
	“字符串”
13
	“时间”
14

15
	"google.golang.grpc"
16
	"google.golang.grpc"
17
	"google.golang.grpc"
18
	"google.golang.grpc"
19
	"google.golang.grpc"
20

21
	pb "hyperliquid"
22
)
23

24
const (
25
	grpcEndpoint = "endpoint.mainnet.quiknode.pro:10000"
26
	authToken    = "您的认证令牌"
27
	maxRetries   = 10
28
	baseDelay    = 2 * time.秒
29
)
30

31
func streamL4Orderbook(coin string, maxMessages int) error {
32
	fmt.PrintlnPrintln字符串.重复("=", 60))
33
	fmt.Printf("Streaming L4 Orderbook for %s\n", coin)
34
	fmt.Println("自动重连：true")
35
	fmt.PrintlnPrintln字符串.重复("=", 60) + "\n")
36

37
	retryCount := 0
38
	totalMsgCount := 0
39

40
	for retryCount < maxRetries {
41
		creds := 凭证.NewClientTLSFromCert(nil, "")
42
		conn, err := grpc.Dial(grpcEndpoint,
43
			grpc.WithTransportCredentials(creds)，
44
			grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(100*1024*1024)))
45
		如果 err != nil {
46
			返回 fmt.Errorf("连接失败：%w", err)
47
		}
48

49
		client := pb.NewOrderBookStreamingClient(conn)
50
		ctx := 元数据.AppendToOutgoingContext(context.背景(), “x-token”, authToken)
51

52
		request := &pb.L4BookRequest{
53
			Coin: coin,
54
		}
55

56
		if retryCount > 0 {
57
			fmt.Printf("\n🔄 正在重新连接（尝试 %d/%d）...\n", retryCount+1, maxRetries)
58
		} else {
59
			fmt.Printf("正在连接到 %s...\n", grpcEndpoint)
60
		}
61

62
		stream, err := client.StreamL4Book(ctx, request)
63
		如果 err != nil {
64
			conn.关闭()
65
			返回 fmt.Errorf("启动流失败：%w", err)
66
		}
67

68
		snapshotReceived := false
69
		shouldRetry := false
70

71
		用于 {
72
			更新， err := 流.Recv()
73
			如果 err == io.EOF {
74
				换行
75
			}
76
			如果 err != nil {
77
				st， 好的 := 状态.FromError(err)
78
				如果 好的 && st.代码() == 代码.DataLoss {
79
					fmt.Printf("\n⚠️  服务器已重新初始化：%s\n", st.消息())
80
					retryCount++
81
					if retryCount < maxRetries {
82
						延迟 := baseDelay * time.Duration(数学.Pow(2, float64(重试次数-1)))
83
						fmt.Printf("⏳ 等待 %v 后再重新连接……\n", 延迟)
84
						时间.睡眠(延迟)
85
						shouldRetry = true
86
						换行
87
					} else {
88
						fmt.Printf("\n❌ 达到最大重试次数 (%d)。放弃。\n", maxRetries)
89
						conn.关闭()
90
						返回 nil
91
					}
92
				}
93
				conn.关闭()
94
				返回 fmt.Errorf("流错误：%w", err)
95
			}
96

97
			totalMsgCount++
98

99
			if snapshot := update.GetSnapshot(); snapshot != nil {
100
				snapshotReceived = true
101
				retryCount = 0 // 成功后重置
102

103
				fmt.Println("\n✓ L4 Snapshot Received!")
104
				fmt.Println(strings.Repeat("─", 60))
105
				fmt.Printf("Coin: %s\n", snapshot.Coin)
106
				fmt.Printf("Height: %d\n", snapshot.Height)
107
				fmt.Printf("Time: %d\n", snapshot.Time)
108
				fmt.Printf("Bids: %d orders\n", len(snapshot.Bids))
109
				fmt.Printf("Asks: %d orders\n", len(snapshot.Asks))
110
				fmt.Println(strings.Repeat("─", 60))
111

112
				// Sample bids
113
				if len(snapshot.Bids) > 0 {
114
					fmt.Println("\nSample Bids (first 5):")
115
					bidCount := len(snapshot.Bids)
116
					if bidCount > 5 {
117
						bidCount = 5
118
					}
119
					for i := 0; i < bidCount; i++ {
120
						order := snapshot.Bids[i]
121
						userShort := order.User
122
						if len(userShort) > 10 {
123
							userShort = userShort[:10] + "..."
124
						}
125
						fmt.Printf("  OID: %d | Price: %s | Size: %s | User: %s\n",
126
							order.Oid, order.LimitPx, order.Sz, userShort)
127
					}
128
				}
129

130
				// Sample asks
131
				if len(snapshot.Asks) > 0 {
132
					fmt.Println("\nSample Asks (first 5):")
133
					askCount := len(snapshot.Asks)
134
					if askCount > 5 {
135
						askCount = 5
136
					}
137
					for i := 0; i < askCount; i++ {
138
						order := snapshot.Asks[i]
139
						userShort := order.User
140
						if len(userShort) > 10 {
141
							userShort = userShort[:10] + "..."
142
						}
143
						fmt.Printf("  OID: %d | Price: %s | Size: %s | User: %s\n",
144
							order.Oid, order.LimitPx, order.Sz, userShort)
145
					}
146
				}
147

148
			} else if diff := update.GetDiff(); diff != nil {
149
				if !snapshotReceived {
150
					fmt.Println("\n⚠ Received diff before snapshot")
151
				}
152

153
				var diffData map[string]interface{}
154
				if err := json.Unmarshal([]byte(diff.Data), &diffData); err == nil {
155
					orderStatuses := []interface{}{}
156
					bookDiffs := []interface{}{}
157

158
					if os, ok := diffData["order_statuses"].([]interface{}); ok {
159
						orderStatuses = os
160
					}
161
					if bd, ok := diffData["book_diffs"].([]interface{}); ok {
162
						bookDiffs = bd
163
					}
164

165
					fmt.Printf("\n[Block %d] L4 Diff:\n", diff.Height)
166
					fmt.Printf("  Time: %d\n", diff.Time)
167
					fmt.Printf("  Order Statuses: %d\n", len(orderStatuses))
168
					fmt.Printf("  Book Diffs: %d\n", len(bookDiffs))
169

170
					if len(bookDiffs) > 0 && len(bookDiffs) <= 5 {
171
						pretty, _ := json.MarshalIndent(bookDiffs, "  ", "  ")
172
						fmt.Printf("  Diffs: %s\n", pretty)
173
					}
174
				}
175
			}
176

177
			if maxMessages > 0 && totalMsgCount >= maxMessages {
178
				fmt.Printf("\nReached max messages (%d), stopping...\n", maxMessages)
179
				conn.关闭()
180
				return nil
181
			}
182
		}
183

184
		conn.关闭()
185

186
		如果 !shouldRetry {
187
			换行
188
		}
189
	}
190

191
	返回 nil
192
}
193

194
func main() {
195
	coin := 标志.字符串("coin", "BTC", "要直播的币种代码")
196
	maxMessages := flag.Int("max-messages", 0, "Maximum messages (0 = unlimited)")
197

198
	flag.解析()
199

200
	fmt.Println("\n" + 字符串.重复("=", 60))
201
	fmt.Println("Hyperliquid StreamL4Book Example")
202
	fmt.Printf("Endpoint：%s\n", grpcEndpoint)
203
	fmt.PrintlnPrintln字符串.重复("=", 60))
204

205
	if err := streamL4Orderbook(*coin, *maxMessages); err != nil {
206
		log.致命(err)
207
	}
208
}
209

1
// StreamL4Book Example - Stream individual order data via gRPC
2
const grpc = require(grpc);
3
const protoLoader = require(grpc);
4
const 路径 = require('path');
5

6
const GRPC = endpoint.mainnet.quiknode.pro:10000';
7
const AUTH_TOKEN = '您的认证令牌';
8
const PROTO_PATH = 路径.join(__dirname, 'proto', 'orderbook.proto');
9

10
const 包定义 = protoLoader.loadSync(PROTO_PATH, {
11
  keepCase: true,
12
  多头: 字符串,
13
  枚举: 字符串,
14
  默认值: true,
15
  oneofs: true
16
});
17
const proto = grpc.loadPackageDefinition(packageDefinition).hyperliquid;
18

19
函数 createClient() {
20
  返回 new proto.OrderBookStreaming(
21
    GRPC,
22
    grpc.凭据.createSsl(),
23
    { 'grpc.max_receive_message_length': 100 * 1024 * 1024 }
24
  );
25
}
26

27
// Stream L4 (individual orders) orderbook
28
async function streamL4Orderbook(coin, maxMessages = null, autoReconnect = true, retryCount = 0) {
29
  控制台.日志('='.重复(60));
30
  console.log(`Streaming L4 Orderbook for ${coin}`);
31
  console.log(`Auto-reconnect: ${autoReconnect}`);
32
  控制台.日志('='.重复(60) + '\n');
33

34
  const maxRetries = 10;
35
  const baseDelay = 2000;
36
  let totalMsgCount = 0;
37

38
  while (retryCount < maxRetries) {
39
    const 客户端 = createClient();
40
    const 元数据 = new grpc.元数据();
41
    元数据.添加('x-token', AUTH_TOKEN);
42

43
    const request = { coin: coin };
44

45
    试一试 {
46
      如果 (retryCount > 0) {
47
        console.log(`\n🔄 Reconnecting (attempt ${retryCount + 1}/${maxRetries})...`);
48
      } else {
49
        console.log(`Connecting to ${GRPC_ENDPOINT}...`);
50
      }
51

52
      let snapshotReceived = false;
53
      const call = client.StreamL4Book(request, metadata);
54

55
      call。在('data', (更新) => {
56
        totalMsgCount++;
57

58
        if (update.snapshot) {
59
          const snapshot = update.snapshot;
60
          snapshotReceived = true;
61
          retryCount = 0; // 成功后重置
62

63
          console.log('\n✓ L4 Snapshot Received!');
64
          console.log('─'.repeat(60));
65
          console.log(`Coin: ${snapshot.coin}`);
66
          console.log(`Height: ${snapshot.height}`);
67
          console.log(`Time: ${snapshot.time}`);
68
          console.log(`Bids: ${snapshot.bids.length} orders`);
69
          console.log(`Asks: ${snapshot.asks.length} orders`);
70
          console.log('─'.repeat(60));
71

72
          // Sample bids
73
          if (snapshot.bids.length > 0) {
74
            console.log('\nSample Bids (first 5):');
75
            snapshot.bids.slice(0, 5).forEach(order => {
76
              console.log(`  OID: ${order.oid} | Price: ${order.limit_px} | Size: ${order.sz} | User: ${order.user.substring(0, 10)}...`);
77
            });
78
          }
79

80
          // Sample asks
81
          if (snapshot.asks.length > 0) {
82
            console.log('\nSample Asks (first 5):');
83
            snapshot.asks.slice(0, 5).forEach(order => {
84
              console.log(`  OID: ${order.oid} | Price: ${order.limit_px} | Size: ${order.sz} | User: ${order.user.substring(0, 10)}...`);
85
            });
86
          }
87

88
        } else if (update.diff) {
89
          const diff = update.diff;
90

91
          if (!snapshotReceived) {
92
            console.log('\n⚠ Received diff before snapshot');
93
          }
94

95
          try {
96
            const diffData = JSON.parse(diff.data);
97
            const orderStatuses = diffData.order_statuses || [];
98
            const bookDiffs = diffData.book_diffs || [];
99

100
            console.log(`\n[Block ${diff.height}] L4 Diff:`);
101
            console.log(`  Time: ${diff.time}`);
102
            console.log(`  Order Statuses: ${orderStatuses.length}`);
103
            console.log(`  Book Diffs: ${bookDiffs.length}`);
104

105
            if (bookDiffs.length > 0 && bookDiffs.length <= 5) {
106
              console.log(`  Diffs: ${JSON.stringify(bookDiffs, null, 2)}`);
107
            }
108
          } catch (e) {
109
            console.log(`  Error parsing diff: ${e.message}`);
110
          }
111
        }
112

113
        if (maxMessages && totalMsgCount >= maxMessages) {
114
          console.log(`\nReached max messages (${maxMessages}), stopping...`);
115
          call.cancel();
116
        }
117
      });
118

119
      call。在('error', (err) => {
120
        如果 (err.代码 === grpc.状态.数据丢失 && 自动重连) {
121
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
122
          retryCount++;
123
          if (retryCount < maxRetries) {
124
            const 延迟 = baseDelay * Math.pow(2, retryCount - 1);
125
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
126
            setTimeout(() => streamL4Orderbook(coin, maxMessages, autoReconnect, retryCount), delay);
127
          } else {
128
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
129
          }
130
        } else if (err.code !== grpc.status.CANCELLED) {
131
          控制台.错误('\ngRPC 错误：', err.code, '-', err.message);
132
        }
133
      });
134

135
      call。在('end', () => {
136
        控制台.日志('\n流已结束');
137
      });
138

139
      // Wait for stream to complete
140
      等待 new Promise((决心) => {
141
        call。在('end', resolve);
142
        call。在('error', resolve);
143
      });
144

145
      换行; // 成功后退出重试循环
146

147
    } catch (err) {
148
      控制台.错误('错误：', err.message);
149
      换行;
150
    }
151
  }
152
}
153

154
// Parse command line args
155
const args = process.argv.slice(2);
156
const 硬币 = args.find(a => a.startsWith('--coin='))?.split('=')[1] || 'BTC';
157
const maxMessages = parseInt(args.find(a => a.startsWith('--max-messages='))?.split('=')[1]) || null;
158

159
控制台.日志('\n' + '='.重复(60));
160
console.log('Hyperliquid StreamL4Book Example');
161
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
162
控制台.日志('='.重复(60));
163

164
streamL4Orderbook(coin, maxMessages);
165

1
// StreamL4Book Example - Stream individual order data via gRPC
2
const grpc = require(grpc);
3
const protoLoader = require(grpc);
4
const 路径 = require('path');
5

6
const GRPC = endpoint.mainnet.quiknode.pro:10000';
7
const AUTH_TOKEN = '您的认证令牌';
8
const PROTO_PATH = 路径.join(__dirname, 'proto', 'orderbook.proto');
9

10
const 包定义 = protoLoader.loadSync(PROTO_PATH, {
11
  keepCase: true,
12
  多头: 字符串,
13
  枚举: 字符串,
14
  默认值: true,
15
  oneofs: true
16
});
17
const proto = grpc.loadPackageDefinition(packageDefinition).hyperliquid;
18

19
函数 createClient() {
20
  返回 new proto.OrderBookStreaming(
21
    GRPC,
22
    grpc.凭据.createSsl(),
23
    { 'grpc.max_receive_message_length': 100 * 1024 * 1024 }
24
  );
25
}
26

27
// Stream L4 (individual orders) orderbook
28
async function streamL4Orderbook(coin, maxMessages = null, autoReconnect = true, retryCount = 0) {
29
  控制台.日志('='.重复(60));
30
  console.log(`Streaming L4 Orderbook for ${coin}`);
31
  console.log(`Auto-reconnect: ${autoReconnect}`);
32
  控制台.日志('='.重复(60) + '\n');
33

34
  const maxRetries = 10;
35
  const baseDelay = 2000;
36
  let totalMsgCount = 0;
37

38
  while (retryCount < maxRetries) {
39
    const 客户端 = createClient();
40
    const 元数据 = new grpc.元数据();
41
    元数据.添加('x-token', AUTH_TOKEN);
42

43
    const request = { coin: coin };
44

45
    试一试 {
46
      如果 (retryCount > 0) {
47
        console.log(`\n🔄 Reconnecting (attempt ${retryCount + 1}/${maxRetries})...`);
48
      } else {
49
        console.log(`Connecting to ${GRPC_ENDPOINT}...`);
50
      }
51

52
      let snapshotReceived = false;
53
      const call = client.StreamL4Book(request, metadata);
54

55
      call。在('data', (更新) => {
56
        totalMsgCount++;
57

58
        if (update.snapshot) {
59
          const snapshot = update.snapshot;
60
          snapshotReceived = true;
61
          retryCount = 0; // 成功后重置
62

63
          console.log('\n✓ L4 Snapshot Received!');
64
          console.log('─'.repeat(60));
65
          console.log(`Coin: ${snapshot.coin}`);
66
          console.log(`Height: ${snapshot.height}`);
67
          console.log(`Time: ${snapshot.time}`);
68
          console.log(`Bids: ${snapshot.bids.length} orders`);
69
          console.log(`Asks: ${snapshot.asks.length} orders`);
70
          console.log('─'.repeat(60));
71

72
          // Sample bids
73
          if (snapshot.bids.length > 0) {
74
            console.log('\nSample Bids (first 5):');
75
            snapshot.bids.slice(0, 5).forEach(order => {
76
              console.log(`  OID: ${order.oid} | Price: ${order.limit_px} | Size: ${order.sz} | User: ${order.user.substring(0, 10)}...`);
77
            });
78
          }
79

80
          // Sample asks
81
          if (snapshot.asks.length > 0) {
82
            console.log('\nSample Asks (first 5):');
83
            snapshot.asks.slice(0, 5).forEach(order => {
84
              console.log(`  OID: ${order.oid} | Price: ${order.limit_px} | Size: ${order.sz} | User: ${order.user.substring(0, 10)}...`);
85
            });
86
          }
87

88
        } else if (update.diff) {
89
          const diff = update.diff;
90

91
          if (!snapshotReceived) {
92
            console.log('\n⚠ Received diff before snapshot');
93
          }
94

95
          try {
96
            const diffData = JSON.parse(diff.data);
97
            const orderStatuses = diffData.order_statuses || [];
98
            const bookDiffs = diffData.book_diffs || [];
99

100
            console.log(`\n[Block ${diff.height}] L4 Diff:`);
101
            console.log(`  Time: ${diff.time}`);
102
            console.log(`  Order Statuses: ${orderStatuses.length}`);
103
            console.log(`  Book Diffs: ${bookDiffs.length}`);
104

105
            if (bookDiffs.length > 0 && bookDiffs.length <= 5) {
106
              console.log(`  Diffs: ${JSON.stringify(bookDiffs, null, 2)}`);
107
            }
108
          } catch (e) {
109
            console.log(`  Error parsing diff: ${e.message}`);
110
          }
111
        }
112

113
        if (maxMessages && totalMsgCount >= maxMessages) {
114
          console.log(`\nReached max messages (${maxMessages}), stopping...`);
115
          call.cancel();
116
        }
117
      });
118

119
      call。在('error', (err) => {
120
        如果 (err.代码 === grpc.状态.数据丢失 && 自动重连) {
121
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
122
          retryCount++;
123
          if (retryCount < maxRetries) {
124
            const 延迟 = baseDelay * Math.pow(2, retryCount - 1);
125
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
126
            setTimeout(() => streamL4Orderbook(coin, maxMessages, autoReconnect, retryCount), delay);
127
          } else {
128
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
129
          }
130
        } else if (err.code !== grpc.status.CANCELLED) {
131
          控制台.错误('\ngRPC 错误：', err.code, '-', err.message);
132
        }
133
      });
134

135
      call。在('end', () => {
136
        控制台.日志('\n流已结束');
137
      });
138

139
      // Wait for stream to complete
140
      等待 new Promise((决心) => {
141
        call。在('end', resolve);
142
        call。在('error', resolve);
143
      });
144

145
      换行; // 成功后退出重试循环
146

147
    } catch (err) {
148
      控制台.错误('错误：', err.message);
149
      换行;
150
    }
151
  }
152
}
153

154
// Parse command line args
155
const args = process.argv.slice(2);
156
const 硬币 = args.find(a => a.startsWith('--coin='))?.split('=')[1] || 'BTC';
157
const maxMessages = parseInt(args.find(a => a.startsWith('--max-messages='))?.split('=')[1]) || null;
158

159
控制台.日志('\n' + '='.重复(60));
160
console.log('Hyperliquid StreamL4Book Example');
161
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
162
控制台.日志('='.重复(60));
163

164
streamL4Orderbook(coin, maxMessages);
165

1
#!/usr/bin/env python3
2
"""
3
StreamL4Book Example - Stream individual order data via gRPC
4

5
设置：
6
    pip install grpcio grpcio-tools protobuf zstandard
7
    python -mgrpc.protoc -I../../proto --python_out=.grpc. ../../proto/orderbook.proto
8

9
用法：
10
    python stream_l4_example.py --coin BTC --max-messages 100
11
"""
12

13
import grpc
14
导入 json
15
import sys
16
import 时间
17
import argparse
18
来自 输入 import Optional
19

20
试一试：
21
    import orderbook_pb2 作为 pb
22
    import orderbook_pb2_grpc 为 pb_grpc
23
except ImportError:
24
    打印("错误：未生成 Proto 文件。请运行：")
25
    打印("  python -mgrpc.protoc -I../../proto --python_out=.grpc. ../../proto/orderbook.proto")
26
    sys.exit(1)
27

28
# 配置
29
GRPC= "endpoint.mainnet.quiknode.pro:10000"
30
AUTH_TOKEN = "您的认证令牌"
31

32

33
def stream_l4_orderbook(coin: str, max_messages: Optional[int] = None, auto_reconnect: bool = True):
34
    """
35
    Stream L4 (individual orders) orderbook updates for a coin.
36

37
    参数：
38
        币种：要直播的币种符号（例如，“BTC”、“ETH”）
39
        max_messages: Maximum number of messages to receive (None for unlimited)
40
        auto_reconnect：在发生 DATA_LOSS 错误时自动重新连接（默认值为 True）
41
    """
42
    打印(f"\n{'='*60}")
43
    print(f"Streaming L4 Orderbook for {coin}")
44
    print(f"Auto-reconnect: {auto_reconnect}")
45
    打印(f"{'='*60}\n")
46

47
    retry_count = 0
48
    max_retries = 10
49
    base_delay = 2
50
    total_msg_count = 0
51

52
    while retry_count < max_retries:
53
        频道 = grpc.secure_channel(
54
           GRPC,
55
            grpc.ssl_channel_credentials(),
56
            选项=[
57
                (grpc.max_receive_message_length', 100 * 1024 * 1024),
58
                (grpc.keepalive_time_ms', 30000),
59
            ]
60
        )
61
        占位符 = pb_grpc.订单流存根(channel)
62

63
        request = pb.L4BookRequest(coin=coin)
64

65
        msg_count = 0
66
        snapshot_received = False
67

68
        试一试：
69
            如果 retry_count > 0:
70
                打印(f"\n🔄 正在重新连接（尝试 {重试次数 + 1}/{最大重试次数})...")
71
            else:
72
                打印(f"正在连接到 {GRPC}...")
73

74
            for update in stub.StreamL4Book(request, metadata=[('x-token', AUTH_TOKEN)]):
75
                msg_count += 1
76
                total_msg_count += 1
77

78
                if update.HasField('snapshot'):
79
                    snapshot = update.snapshot
80
                    snapshot_received = True
81
                    retry_count = 0  # 连接成功后重置重试计数
82

83
                    print(f"\n✓ L4 Snapshot Received!")
84
                    print(f"{'─'*60}")
85
                    print(f"Coin: {snapshot.coin}")
86
                    print(f"Height: {snapshot.height}")
87
                    print(f"Time: {snapshot.time}")
88
                    print(f"Bids: {len(snapshot.bids)} orders")
89
                    print(f"Asks: {len(snapshot.asks)} orders")
90
                    print(f"{'─'*60}")
91

92
                    # Show sample of orders
93
                    if snapshot.bids:
94
                        print(f"\nSample Bids (first 5):")
95
                        for order in snapshot.bids[:5]:
96
                            print(f"  OID: {order.oid} | Price: {order.limit_px} | Size: {order.sz} | User: {order.user[:10]}...")
97

98
                    if snapshot.asks:
99
                        print(f"\nSample Asks (first 5):")
100
                        for order in snapshot.asks[:5]:
101
                            print(f"  OID: {order.oid} | Price: {order.limit_px} | Size: {order.sz} | User: {order.user[:10]}...")
102

103
                elif update.HasField('diff'):
104
                    diff = update.diff
105

106
                    if not snapshot_received:
107
                        print(f"\n⚠ Received diff before snapshot")
108

109
                    # Parse the JSON diff data
110
                    try:
111
                        diff_data = json.loads(diff.data)
112
                        order_statuses = diff_data.get('order_statuses', [])
113
                        book_diffs = diff_data.get('book_diffs', [])
114

115
                        print(f"\n[Block {diff.height}] L4 Diff:")
116
                        print(f"  Time: {diff.time}")
117
                        print(f"  Order Statuses: {len(order_statuses)}")
118
                        print(f"  Book Diffs: {len(book_diffs)}")
119

120
                        # Show sample diffs
121
                        if book_diffs and len(book_diffs) <= 5:
122
                            print(f"  Diffs: {json.dumps(book_diffs, indent=4)}")
123

124
                    except json.JSONDecodeError as e:
125
                        print(f"  Error parsing diff data: {e}")
126
                        print(f"  Raw data: {diff.data[:200]}...")
127

128
                if max_messages and total_msg_count >= max_messages:
129
                    print(f"\nReached max messages ({max_messages}), stopping...")
130
                    频道.关闭()
131
                    返回
132

133
        除了 grpc。RpcError 作为 e:
134
            如果 e.代码() == grpc.状态码.DATA_LOSS 和 auto_reconnect：
135
                print(f"\n⚠️  Server reinitialized: {e.details()}")
136
                retry_count += 1
137
                if retry_count < max_retries:
138
                    延迟 = base_delay * (2 ** (重试次数 - 1))  # 指数退避
139
                    打印(f"⏳ 正在等待 {延迟}秒后重新连接...")
140
                    时间.sleep(延迟)
141
                    频道.关闭()
142
                    继续
143
                else:
144
                    打印(f"\n❌ 最大重试次数 ({max_retries}) 已达到。放弃。")
145
                    换行
146
            else:
147
                print(f"\ngRPC error: {e.code()} - {e.details()}")
148
                换行
149
        除了 KeyboardInterrupt:
150
            print("\nStopping L4 stream...")
151
            换行
152
        最后:
153
            频道.关闭()
154

155
        # 如果在此处未出现错误，则退出重试循环
156
        换行
157

158

159
def main():
160
    parser = argparse.ArgumentParser(description='Stream Hyperliquid L4 orderbook data via gRPC')
161
    解析器.add_argument('--coin', 默认='BTC', 帮助='要直播的币种代码')
162
    parser.add_argument('--max-messages', type=int, default=None, help='Maximum number of messages to receive')
163

164
    args = 解析器.parse_args()
165

166
    打印(f"\n{'='*60}")
167
    print("Hyperliquid StreamL4Book Example")
168
    print(f"Endpoint: {GRPC_ENDPOINT}")
169
    打印(f"{'='*60}")
170

171
    试一试：
172
        stream_l4_orderbook(args.coin, max_messages=args.max_messages)
173
    除 异常 作为 e:
174
        print(f"\nError: {e}")
175
        import traceback
176
        回溯.print_exc()
177
        sys.exit(1)
178

179

180
如果 __name__ == "__main__":
181
    主()
182

1
#!/usr/bin/env python3
2
"""
3
StreamL4Book Example - Stream individual order data via gRPC
4

5
设置：
6
    pip install grpcio grpcio-tools protobuf zstandard
7
    python -mgrpc.protoc -I../../proto --python_out=.grpc. ../../proto/orderbook.proto
8

9
用法：
10
    python stream_l4_example.py --coin BTC --max-messages 100
11
"""
12

13
import grpc
14
导入 json
15
import sys
16
import 时间
17
import argparse
18
来自 输入 import Optional
19

20
试一试：
21
    import orderbook_pb2 作为 pb
22
    import orderbook_pb2_grpc 为 pb_grpc
23
except ImportError:
24
    打印("错误：未生成 Proto 文件。请运行：")
25
    打印("  python -mgrpc.protoc -I../../proto --python_out=.grpc. ../../proto/orderbook.proto")
26
    sys.exit(1)
27

28
# 配置
29
GRPC= "endpoint.mainnet.quiknode.pro:10000"
30
AUTH_TOKEN = "您的认证令牌"
31

32

33
def stream_l4_orderbook(coin: str, max_messages: Optional[int] = None, auto_reconnect: bool = True):
34
    """
35
    Stream L4 (individual orders) orderbook updates for a coin.
36

37
    参数：
38
        币种：要直播的币种符号（例如，“BTC”、“ETH”）
39
        max_messages: Maximum number of messages to receive (None for unlimited)
40
        auto_reconnect：在发生 DATA_LOSS 错误时自动重新连接（默认值为 True）
41
    """
42
    打印(f"\n{'='*60}")
43
    print(f"Streaming L4 Orderbook for {coin}")
44
    print(f"Auto-reconnect: {auto_reconnect}")
45
    打印(f"{'='*60}\n")
46

47
    retry_count = 0
48
    max_retries = 10
49
    base_delay = 2
50
    total_msg_count = 0
51

52
    while retry_count < max_retries:
53
        频道 = grpc.secure_channel(
54
           GRPC,
55
            grpc.ssl_channel_credentials(),
56
            选项=[
57
                (grpc.max_receive_message_length', 100 * 1024 * 1024),
58
                (grpc.keepalive_time_ms', 30000),
59
            ]
60
        )
61
        占位符 = pb_grpc.订单流存根(channel)
62

63
        request = pb.L4BookRequest(coin=coin)
64

65
        msg_count = 0
66
        snapshot_received = False
67

68
        试一试：
69
            如果 retry_count > 0:
70
                打印(f"\n🔄 正在重新连接（尝试 {重试次数 + 1}/{最大重试次数})...")
71
            else:
72
                打印(f"正在连接到 {GRPC}...")
73

74
            for update in stub.StreamL4Book(request, metadata=[('x-token', AUTH_TOKEN)]):
75
                msg_count += 1
76
                total_msg_count += 1
77

78
                if update.HasField('snapshot'):
79
                    snapshot = update.snapshot
80
                    snapshot_received = True
81
                    retry_count = 0  # 连接成功后重置重试计数
82

83
                    print(f"\n✓ L4 Snapshot Received!")
84
                    print(f"{'─'*60}")
85
                    print(f"Coin: {snapshot.coin}")
86
                    print(f"Height: {snapshot.height}")
87
                    print(f"Time: {snapshot.time}")
88
                    print(f"Bids: {len(snapshot.bids)} orders")
89
                    print(f"Asks: {len(snapshot.asks)} orders")
90
                    print(f"{'─'*60}")
91

92
                    # Show sample of orders
93
                    if snapshot.bids:
94
                        print(f"\nSample Bids (first 5):")
95
                        for order in snapshot.bids[:5]:
96
                            print(f"  OID: {order.oid} | Price: {order.limit_px} | Size: {order.sz} | User: {order.user[:10]}...")
97

98
                    if snapshot.asks:
99
                        print(f"\nSample Asks (first 5):")
100
                        for order in snapshot.asks[:5]:
101
                            print(f"  OID: {order.oid} | Price: {order.limit_px} | Size: {order.sz} | User: {order.user[:10]}...")
102

103
                elif update.HasField('diff'):
104
                    diff = update.diff
105

106
                    if not snapshot_received:
107
                        print(f"\n⚠ Received diff before snapshot")
108

109
                    # Parse the JSON diff data
110
                    try:
111
                        diff_data = json.loads(diff.data)
112
                        order_statuses = diff_data.get('order_statuses', [])
113
                        book_diffs = diff_data.get('book_diffs', [])
114

115
                        print(f"\n[Block {diff.height}] L4 Diff:")
116
                        print(f"  Time: {diff.time}")
117
                        print(f"  Order Statuses: {len(order_statuses)}")
118
                        print(f"  Book Diffs: {len(book_diffs)}")
119

120
                        # Show sample diffs
121
                        if book_diffs and len(book_diffs) <= 5:
122
                            print(f"  Diffs: {json.dumps(book_diffs, indent=4)}")
123

124
                    except json.JSONDecodeError as e:
125
                        print(f"  Error parsing diff data: {e}")
126
                        print(f"  Raw data: {diff.data[:200]}...")
127

128
                if max_messages and total_msg_count >= max_messages:
129
                    print(f"\nReached max messages ({max_messages}), stopping...")
130
                    频道.关闭()
131
                    返回
132

133
        除了 grpc。RpcError 作为 e:
134
            如果 e.代码() == grpc.状态码.DATA_LOSS 和 auto_reconnect：
135
                print(f"\n⚠️  Server reinitialized: {e.details()}")
136
                retry_count += 1
137
                if retry_count < max_retries:
138
                    延迟 = base_delay * (2 ** (重试次数 - 1))  # 指数退避
139
                    打印(f"⏳ 正在等待 {延迟}秒后重新连接...")
140
                    时间.sleep(延迟)
141
                    频道.关闭()
142
                    继续
143
                else:
144
                    打印(f"\n❌ 最大重试次数 ({max_retries}) 已达到。放弃。")
145
                    换行
146
            else:
147
                print(f"\ngRPC error: {e.code()} - {e.details()}")
148
                换行
149
        除了 KeyboardInterrupt:
150
            print("\nStopping L4 stream...")
151
            换行
152
        最后:
153
            频道.关闭()
154

155
        # 如果在此处未出现错误，则退出重试循环
156
        换行
157

158

159
def main():
160
    parser = argparse.ArgumentParser(description='Stream Hyperliquid L4 orderbook data via gRPC')
161
    解析器.add_argument('--coin', 默认='BTC', 帮助='要直播的币种代码')
162
    parser.add_argument('--max-messages', type=int, default=None, help='Maximum number of messages to receive')
163

164
    args = 解析器.parse_args()
165

166
    打印(f"\n{'='*60}")
167
    print("Hyperliquid StreamL4Book Example")
168
    print(f"Endpoint: {GRPC_ENDPOINT}")
169
    打印(f"{'='*60}")
170

171
    试一试：
172
        stream_l4_orderbook(args.coin, max_messages=args.max_messages)
173
    除 异常 作为 e:
174
        print(f"\nError: {e}")
175
        import traceback
176
        回溯.print_exc()
177
        sys.exit(1)
178

179

180
如果 __name__ == "__main__":
181
    主()
182

还没有账号吗？

endpoint 几秒钟endpoint 创建您的Quicknode endpoint ，并开始构建

免费开始使用