StreamL2BookgRPC

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

参数

硬币

字符串

正在加载...

n_levels

uint32

正在加载...

n_sig_figs

uint32

正在加载...

尾数

uint64

正在加载...

退货

流

stream<L2BookUpdate>

正在加载...

硬币

字符串

正在加载...

时间

uint64

正在加载...

区块号

uint64

正在加载...

出价

array<L2Level>

正在加载...

询问

array<L2Level>

正在加载...

请求

1
// StreamL2Book Example - Stream aggregated orderbook data via gRPC
2
包 main
3

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

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

20
	pb "hyperliquid"
21
)
22

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

30
func streamL2Orderbook(币种 字符串, nLevels uint32) error {
31
	fmt.PrintlnPrintln字符串.重复("=", 60))
32
	fmt.Printf("%s 的 L2 订单簿流式传输\n", coin)
33
	fmt.Printf("水位：%d\n", nLevels)
34
	fmt.Println("自动重连：true")
35
	fmt.PrintlnPrintln字符串.重复("=", 60) + "\n")
36

37
	retryCount := 0
38

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

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

51
		request := &pb.L2BookRequest{
52
			硬币:    硬币,
53
			NLevels: nLevels,
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
		流, err := client.StreamL2Book(ctx, request)
63
		如果 err != nil {
64
			conn.关闭()
65
			返回 fmt.Errorf("启动流失败：%w", err)
66
		}
67

68
		msgCount := 0
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
			msgCount++
98
			如果 msgCount == 1 {
99
				fmt.Println("✓ 已收到首次 L2 更新！\n")
100
				retryCount = 0 // 成功后重置
101
			}
102

103
			// Display orderbook
104
			fmt.Println("\n" + 字符串.重复("─", 60))
105
			fmt.Printf("方块：%d | 时间：%d | 金币：%s\n", update.区块号, 更新.Time, 更新.硬币)
106
			fmt.PrintlnPrintln字符串.重复("─", 60))
107

108
			// Display asks (reversed)
109
			如果 len(update.询问) > 0 {
110
				fmt.Println("\n  ASKS:")
111
				askCount := len(update.询问)
112
				如果 askCount > 10 {
113
					askCount = 10
114
				}
115
				for i := askCount - 1; i >= 0; i-- {
116
					level := 更新.查询[i]
117
					fmt.Printf("    %12s | %12s | (%d 笔订单)\n", level.Px, level.Sz, level.N)
118
				}
119
			}
120

121
			// Display spread
122
			如果 len(update.出价) > 0 && len(update.询问) > 0 {
123
				fmt.Println("\n  " + 字符串.重复("─", 44))
124
				fmt.Printf("  点差：（最佳买价：%s，最佳卖价：%s）\n", update.买价[0].Px, 更新.询问[0].Px)
125
				fmt.Println("  " + 字符串.重复("─", 44))
126
			}
127

128
			// Display bids
129
			如果 len(update.出价) > 0 {
130
				fmt.Println("\n  买入价：")
131
				bidCount := len(update.买单)
132
				如果 bidCount > 10 {
133
					bidCount = 10
134
				}
135
				for i := 0; i < bidCount; i++ {
136
					level := 更新.买单[i]
137
					fmt.Printf("    %12s | %12s | (%d 笔订单)\n", level.Px, level.Sz, level.N)
138
				}
139
			}
140

141
			fmt.Printf("\n  已接收消息：%d\n", msgCount)
142
		}
143

144
		conn.关闭()
145

146
		如果 !shouldRetry {
147
			换行
148
		}
149
	}
150

151
	返回 nil
152
}
153

154
func main() {
155
	coin := 标志.字符串("coin", "BTC", "要直播的币种代码")
156
	级别 := 标志.Uint("levels", 20, "价格层级数")
157

158
	flag.解析()
159

160
	fmt.Println("\n" + 字符串.重复("=", 60))
161
	fmt.Println("Hyperliquid 示例")
162
	fmt.Printf("Endpoint：%s\n", grpcEndpoint)
163
	fmt.PrintlnPrintln字符串.重复("=", 60))
164

165
	if err := streamL2Orderbook(*coin, uint32(*levels)); err != nil {
166
		log.致命(err)
167
	}
168
}
169

1
// StreamL2Book Example - Stream aggregated orderbook data via gRPC
2
包 main
3

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

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

20
	pb "hyperliquid"
21
)
22

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

30
func streamL2Orderbook(币种 字符串, nLevels uint32) error {
31
	fmt.PrintlnPrintln字符串.重复("=", 60))
32
	fmt.Printf("%s 的 L2 订单簿流式传输\n", coin)
33
	fmt.Printf("水位：%d\n", nLevels)
34
	fmt.Println("自动重连：true")
35
	fmt.PrintlnPrintln字符串.重复("=", 60) + "\n")
36

37
	retryCount := 0
38

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

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

51
		request := &pb.L2BookRequest{
52
			硬币:    硬币,
53
			NLevels: nLevels,
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
		流, err := client.StreamL2Book(ctx, request)
63
		如果 err != nil {
64
			conn.关闭()
65
			返回 fmt.Errorf("启动流失败：%w", err)
66
		}
67

68
		msgCount := 0
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
			msgCount++
98
			如果 msgCount == 1 {
99
				fmt.Println("✓ 已收到首次 L2 更新！\n")
100
				retryCount = 0 // 成功后重置
101
			}
102

103
			// Display orderbook
104
			fmt.Println("\n" + 字符串.重复("─", 60))
105
			fmt.Printf("方块：%d | 时间：%d | 金币：%s\n", update.区块号, 更新.Time, 更新.硬币)
106
			fmt.PrintlnPrintln字符串.重复("─", 60))
107

108
			// Display asks (reversed)
109
			如果 len(update.询问) > 0 {
110
				fmt.Println("\n  ASKS:")
111
				askCount := len(update.询问)
112
				如果 askCount > 10 {
113
					askCount = 10
114
				}
115
				for i := askCount - 1; i >= 0; i-- {
116
					level := 更新.查询[i]
117
					fmt.Printf("    %12s | %12s | (%d 笔订单)\n", level.Px, level.Sz, level.N)
118
				}
119
			}
120

121
			// Display spread
122
			如果 len(update.出价) > 0 && len(update.询问) > 0 {
123
				fmt.Println("\n  " + 字符串.重复("─", 44))
124
				fmt.Printf("  点差：（最佳买价：%s，最佳卖价：%s）\n", update.买价[0].Px, 更新.询问[0].Px)
125
				fmt.Println("  " + 字符串.重复("─", 44))
126
			}
127

128
			// Display bids
129
			如果 len(update.出价) > 0 {
130
				fmt.Println("\n  买入价：")
131
				bidCount := len(update.买单)
132
				如果 bidCount > 10 {
133
					bidCount = 10
134
				}
135
				for i := 0; i < bidCount; i++ {
136
					level := 更新.买单[i]
137
					fmt.Printf("    %12s | %12s | (%d 笔订单)\n", level.Px, level.Sz, level.N)
138
				}
139
			}
140

141
			fmt.Printf("\n  已接收消息：%d\n", msgCount)
142
		}
143

144
		conn.关闭()
145

146
		如果 !shouldRetry {
147
			换行
148
		}
149
	}
150

151
	返回 nil
152
}
153

154
func main() {
155
	coin := 标志.字符串("coin", "BTC", "要直播的币种代码")
156
	级别 := 标志.Uint("levels", 20, "价格层级数")
157

158
	flag.解析()
159

160
	fmt.Println("\n" + 字符串.重复("=", 60))
161
	fmt.Println("Hyperliquid 示例")
162
	fmt.Printf("Endpoint：%s\n", grpcEndpoint)
163
	fmt.PrintlnPrintln字符串.重复("=", 60))
164

165
	if err := streamL2Orderbook(*coin, uint32(*levels)); err != nil {
166
		log.致命(err)
167
	}
168
}
169

1
// StreamL2Book Example - Stream aggregated orderbook 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 L2 (aggregated) orderbook
28
async 函数 streamL2Orderbook(币种, nLevels = 20, autoReconnect = true, 重试次数 = 0) {
29
  控制台.日志('='.重复(60));
30
  console.log(`Streaming L2 Orderbook for ${coin}`);
31
  console.log(`Levels: ${nLevels}`);
32
  console.log(`Auto-reconnect: ${autoReconnect}`);
33
  控制台.日志('='.重复(60) + '\n');
34

35
  const maxRetries = 10;
36
  const baseDelay = 2000;
37

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

43
    const 请求 = {
44
      硬币: 硬币,
45
      n_levels: nLevels
46
    };
47

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

55
      let msgCount = 0;
56
      const 调用 = 客户端.StreamL2Book(请求, 元数据);
57

58
      call。在('data', (更新) => {
59
        msgCount++;
60

61
        如果 (msgCount === 1) {
62
          控制台.日志('✓ 已收到首次 L2 更新！\n');
63
          retryCount = 0; // 成功后重置
64
        }
65

66
        控制台.日志('\n' + '─'.重复(60));
67
        console.log(`Block: ${update.block_number} | Time: ${update.time} | Coin: ${update.coin}`);
68
        控制台.日志('─'.重复(60));
69

70
        // Display asks (reversed for display)
71
        如果 (更新.询问 && 更新.询问.长度 > 0) {
72
          控制台.日志('\n  ASKS:');
73
          更新.询问.切片(0, 10).reverse().forEach(level => {
74
            console.log(`    ${level.px.padStart(12)} | ${level.sz.padStart(12)} | (${level.n} orders)`);
75
          });
76
        }
77

78
        // Display spread
79
        如果 (更新.出价 && 更新.出价.长度 > 0 && update.询问 && 更新.询问.长度 > 0) {
80
          const bestBid = parseFloat(update.bids[0].px);
81
          const bestAsk = parseFloat(update.询问[0].px);
82
          const spread = bestAsk - 最佳买价;
83
          const spreadBps = (spread / bestBid) * 10000;
84
          控制台.日志('\n  ' + '─'.重复(44));
85
          console.log(`  SPREAD: ${spread.toFixed(2)} (${spreadBps.toFixed(2)} bps)`);
86
          控制台.日志('  ' + '─'.重复(44));
87
        }
88

89
        // Display bids
90
        如果 (更新.出价 && 更新.出价.长度 > 0) {
91
          控制台.日志('\n  BIDS:');
92
          更新.出价.切片(0, 10).forEach(level => {
93
            console.log(`    ${level.px.padStart(12)} | ${level.sz.padStart(12)} | (${level.n} orders)`);
94
          });
95
        }
96

97
        console.log(`\n  Messages received: ${msgCount}`);
98
      });
99

100
      call。在('error', (err) => {
101
        如果 (err.代码 === grpc.状态.数据丢失 && 自动重连) {
102
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
103
          retryCount++;
104
          if (retryCount < maxRetries) {
105
            const 延迟 = baseDelay * Math.pow(2, retryCount - 1);
106
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
107
            setTimeout(() => streamL2Orderbook(币种, nLevels, autoReconnect, 重试次数), 延迟);
108
          } else {
109
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
110
          }
111
        } else {
112
          控制台.错误('\ngRPC 错误：', err.code, '-', err.message);
113
        }
114
      });
115

116
      call。在('end', () => {
117
        控制台.日志('\n流已结束');
118
      });
119

120
      // Wait for stream to complete
121
      等待 new Promise((决心) => {
122
        call。在('end', resolve);
123
        call。在('error', resolve);
124
      });
125

126
      换行; // 成功后退出重试循环
127

128
    } catch (err) {
129
      控制台.错误('错误：', err.message);
130
      换行;
131
    }
132
  }
133
}
134

135
// Parse command line args
136
const args = process.argv.slice(2);
137
const 硬币 = args.find(a => a.startsWith('--coin='))?.split('=')[1] || 'BTC';
138
const 等级 = parseInt(args.find(a => a.startsWith('--levels='))?.split('=')[1]) || 20;
139

140
控制台.日志('\n' + '='.重复(60));
141
控制台.日志(Hyperliquid 示例');
142
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
143
控制台.日志('='.重复(60));
144

145
streamL2Orderbook(币种, 级别);
146

1
// StreamL2Book Example - Stream aggregated orderbook 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 L2 (aggregated) orderbook
28
async 函数 streamL2Orderbook(币种, nLevels = 20, autoReconnect = true, 重试次数 = 0) {
29
  控制台.日志('='.重复(60));
30
  console.log(`Streaming L2 Orderbook for ${coin}`);
31
  console.log(`Levels: ${nLevels}`);
32
  console.log(`Auto-reconnect: ${autoReconnect}`);
33
  控制台.日志('='.重复(60) + '\n');
34

35
  const maxRetries = 10;
36
  const baseDelay = 2000;
37

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

43
    const 请求 = {
44
      硬币: 硬币,
45
      n_levels: nLevels
46
    };
47

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

55
      let msgCount = 0;
56
      const 调用 = 客户端.StreamL2Book(请求, 元数据);
57

58
      call。在('data', (更新) => {
59
        msgCount++;
60

61
        如果 (msgCount === 1) {
62
          控制台.日志('✓ 已收到首次 L2 更新！\n');
63
          retryCount = 0; // 成功后重置
64
        }
65

66
        控制台.日志('\n' + '─'.重复(60));
67
        console.log(`Block: ${update.block_number} | Time: ${update.time} | Coin: ${update.coin}`);
68
        控制台.日志('─'.重复(60));
69

70
        // Display asks (reversed for display)
71
        如果 (更新.询问 && 更新.询问.长度 > 0) {
72
          控制台.日志('\n  ASKS:');
73
          更新.询问.切片(0, 10).reverse().forEach(level => {
74
            console.log(`    ${level.px.padStart(12)} | ${level.sz.padStart(12)} | (${level.n} orders)`);
75
          });
76
        }
77

78
        // Display spread
79
        如果 (更新.出价 && 更新.出价.长度 > 0 && update.询问 && 更新.询问.长度 > 0) {
80
          const bestBid = parseFloat(update.bids[0].px);
81
          const bestAsk = parseFloat(update.询问[0].px);
82
          const spread = bestAsk - 最佳买价;
83
          const spreadBps = (spread / bestBid) * 10000;
84
          控制台.日志('\n  ' + '─'.重复(44));
85
          console.log(`  SPREAD: ${spread.toFixed(2)} (${spreadBps.toFixed(2)} bps)`);
86
          控制台.日志('  ' + '─'.重复(44));
87
        }
88

89
        // Display bids
90
        如果 (更新.出价 && 更新.出价.长度 > 0) {
91
          控制台.日志('\n  BIDS:');
92
          更新.出价.切片(0, 10).forEach(level => {
93
            console.log(`    ${level.px.padStart(12)} | ${level.sz.padStart(12)} | (${level.n} orders)`);
94
          });
95
        }
96

97
        console.log(`\n  Messages received: ${msgCount}`);
98
      });
99

100
      call。在('error', (err) => {
101
        如果 (err.代码 === grpc.状态.数据丢失 && 自动重连) {
102
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
103
          retryCount++;
104
          if (retryCount < maxRetries) {
105
            const 延迟 = baseDelay * Math.pow(2, retryCount - 1);
106
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
107
            setTimeout(() => streamL2Orderbook(币种, nLevels, autoReconnect, 重试次数), 延迟);
108
          } else {
109
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
110
          }
111
        } else {
112
          控制台.错误('\ngRPC 错误：', err.code, '-', err.message);
113
        }
114
      });
115

116
      call。在('end', () => {
117
        控制台.日志('\n流已结束');
118
      });
119

120
      // Wait for stream to complete
121
      等待 new Promise((决心) => {
122
        call。在('end', resolve);
123
        call。在('error', resolve);
124
      });
125

126
      换行; // 成功后退出重试循环
127

128
    } catch (err) {
129
      控制台.错误('错误：', err.message);
130
      换行;
131
    }
132
  }
133
}
134

135
// Parse command line args
136
const args = process.argv.slice(2);
137
const 硬币 = args.find(a => a.startsWith('--coin='))?.split('=')[1] || 'BTC';
138
const 等级 = parseInt(args.find(a => a.startsWith('--levels='))?.split('=')[1]) || 20;
139

140
控制台.日志('\n' + '='.重复(60));
141
控制台.日志(Hyperliquid 示例');
142
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
143
控制台.日志('='.重复(60));
144

145
streamL2Orderbook(币种, 级别);
146

1
#!/usr/bin/env python3
2
"""
3
StreamL2Book 示例——通过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_l2_example.py --coin BTC --levels 20
11
"""
12

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

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

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

31

32
def stream_l2_orderbook(币种: str, n_levels: int = 20, n_sig_figs: 可选[int] = None, 尾数: 可选[int] = None, auto_reconnect: bool = True):
33
    """
34
    流式传输某币种的 L2（聚合）订单簿更新。
35

36
    参数：
37
        币种：要直播的币种符号（例如，“BTC”、“ETH”）
38
        n_levels：要显示的价格级别数量（默认值为 20，最大值为 100）
39
        n_sig_figs：价格分档的有效数字（2-5）
40
        尾数：用于分桶的尾数（1、2 或 5）
41
        auto_reconnect：在发生 DATA_LOSS 错误时自动重新连接（默认值为 True）
42
    """
43
    打印(f"\n{'='*60}")
44
    打印(f"流式传输 L2 订单簿，用于 {币种}")
45
    print(f"Levels: {n_levels}")
46
    print(f"Auto-reconnect: {auto_reconnect}")
47
    打印(f"{'='*60}\n")
48

49
    retry_count = 0
50
    max_retries = 10
51
    base_delay = 2
52

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

64
        # 构建请求
65
        请求 = pb.L2BookRequest(
66
            硬币=硬币,
67
            n_levels=n_levels
68
        )
69
        如果 n_sig_figs 为 不 None时：
70
            请求.n_sig_figs = n_sig_figs
71
        如果 尾数 是 不 None:
72
            请求.尾数 = 尾数
73

74
        msg_count = 0
75

76
        试一试：
77
            如果 retry_count > 0:
78
                打印(f"\n🔄 正在重新连接（尝试 {重试次数 + 1}/{最大重试次数})...")
79
            else:
80
                打印(f"正在连接到 {GRPC}...")
81

82
            用于 更新 在 存根中。StreamL2Book(请求, 元数据=[('x-token', AUTH_TOKEN)]):
83
                msg_count += 1
84

85
                如果 msg_count == 1:
86
                    打印(f"✓ 收到首个 L2 更新！\n")
87
                    retry_count = 0  # 连接成功后重置重试计数
88

89
                # 显示 L2 订单簿
90
                打印(f"\n{'─'*60}")
91
                print(f"Block: {update.block_number} | Time: {update.time} | Coin: {update.coin}")
92
                打印(f"{'─'*60}")
93

94
                # 显示问题（按得分从高到低排序显示）
95
                如果 更新.询问：
96
                    打印("\n  ASKS:")
97
                    用于 级别 在 反向(列表(更新.询问[:10])):  # 十大请求
98
                        print(f"    {level.px:>12} | {level.sz:>12} | ({level.n} orders)")
99

100
                # 显示点差
101
                如果 更新.出价 和 update.询价：
102
                    best_bid = float(update.出价[0].px) 如果 更新.出价 else 0
103
                    best_ask = float(更新.询问[0].px) 如果 更新.询问 else 0
104
                    如果 best_bid 且 best_ask：
105
                        spread = 最佳卖价 - 最佳买价
106
                        spread_bps = (点差 / 最佳买价) * 10000 如果 best_bid > 0 else 0
107
                        打印(f"\n  {'─'*44}")
108
                        print(f"  SPREAD: {spread:.2f} ({spread_bps:.2f} bps)")
109
                        打印(f"  {'─'*44}")
110

111
                # 显示出价
112
                如果 更新.出价:
113
                    打印("\n  BIDS:")
114
                    用于 级别 在 update中。出价[:10]:  # 前10名出价
115
                        print(f"    {level.px:>12} | {level.sz:>12} | ({level.n} orders)")
116

117
                print(f"\n  Messages received: {msg_count}")
118

119
        除了 grpc。RpcError 作为 e:
120
            如果 e.代码() == grpc.状态码.DATA_LOSS 和 auto_reconnect：
121
                print(f"\n⚠️  Server reinitialized: {e.details()}")
122
                retry_count += 1
123
                if retry_count < max_retries:
124
                    延迟 = base_delay * (2 ** (重试次数 - 1))  # 指数退避
125
                    打印(f"⏳ 正在等待 {延迟}秒后重新连接...")
126
                    时间.sleep(延迟)
127
                    频道.关闭()
128
                    继续
129
                else:
130
                    打印(f"\n❌ 最大重试次数 ({max_retries}) 已达到。放弃。")
131
                    换行
132
            else:
133
                print(f"\ngRPC error: {e.code()} - {e.details()}")
134
                换行
135
        除了 KeyboardInterrupt:
136
            打印("\n停止 L2 流...")
137
            换行
138
        最后:
139
            频道.关闭()
140

141
        # 如果在此处未出现错误，则退出重试循环
142
        换行
143

144

145
def main():
146
    解析器 = argparse.ArgumentParser(描述='通过 gRPC 流式传输Hyperliquid 订单簿数据gRPC)
147
    解析器.add_argument('--coin', 默认='BTC', 帮助='要直播的币种代码')
148
    解析器.add_argument('--levels', type=int, 默认值=20, 帮助='价格层级数量（默认：20，最大：100）')
149
    解析器.add_argument('--sig-figs', type=int, 默认值=None, 帮助='分桶法中的有效数字（2-5）')
150
    解析器.add_argument('--mantissa', type=int, 默认值=None, 帮助='分桶小数部分（1、2 或 5）')
151

152
    args = 解析器.parse_args()
153

154
    打印(f"\n{'='*60}")
155
    打印(Hyperliquid 示例”)
156
    print(f"Endpoint: {GRPC_ENDPOINT}")
157
    打印(f"{'='*60}")
158

159
    试一试：
160
        stream_l2_orderbook(参数.coin, n_levels=args.levels, n_sig_figs=args.sig_figs, 尾数=args.尾数)
161
    除 异常 作为 e:
162
        print(f"\nError: {e}")
163
        import traceback
164
        回溯.print_exc()
165
        sys.exit(1)
166

167

168
如果 __name__ == "__main__":
169
    主()
170

1
#!/usr/bin/env python3
2
"""
3
StreamL2Book 示例——通过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_l2_example.py --coin BTC --levels 20
11
"""
12

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

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

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

31

32
def stream_l2_orderbook(币种: str, n_levels: int = 20, n_sig_figs: 可选[int] = None, 尾数: 可选[int] = None, auto_reconnect: bool = True):
33
    """
34
    流式传输某币种的 L2（聚合）订单簿更新。
35

36
    参数：
37
        币种：要直播的币种符号（例如，“BTC”、“ETH”）
38
        n_levels：要显示的价格级别数量（默认值为 20，最大值为 100）
39
        n_sig_figs：价格分档的有效数字（2-5）
40
        尾数：用于分桶的尾数（1、2 或 5）
41
        auto_reconnect：在发生 DATA_LOSS 错误时自动重新连接（默认值为 True）
42
    """
43
    打印(f"\n{'='*60}")
44
    打印(f"流式传输 L2 订单簿，用于 {币种}")
45
    print(f"Levels: {n_levels}")
46
    print(f"Auto-reconnect: {auto_reconnect}")
47
    打印(f"{'='*60}\n")
48

49
    retry_count = 0
50
    max_retries = 10
51
    base_delay = 2
52

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

64
        # 构建请求
65
        请求 = pb.L2BookRequest(
66
            硬币=硬币,
67
            n_levels=n_levels
68
        )
69
        如果 n_sig_figs 为 不 None时：
70
            请求.n_sig_figs = n_sig_figs
71
        如果 尾数 是 不 None:
72
            请求.尾数 = 尾数
73

74
        msg_count = 0
75

76
        试一试：
77
            如果 retry_count > 0:
78
                打印(f"\n🔄 正在重新连接（尝试 {重试次数 + 1}/{最大重试次数})...")
79
            else:
80
                打印(f"正在连接到 {GRPC}...")
81

82
            用于 更新 在 存根中。StreamL2Book(请求, 元数据=[('x-token', AUTH_TOKEN)]):
83
                msg_count += 1
84

85
                如果 msg_count == 1:
86
                    打印(f"✓ 收到首个 L2 更新！\n")
87
                    retry_count = 0  # 连接成功后重置重试计数
88

89
                # 显示 L2 订单簿
90
                打印(f"\n{'─'*60}")
91
                print(f"Block: {update.block_number} | Time: {update.time} | Coin: {update.coin}")
92
                打印(f"{'─'*60}")
93

94
                # 显示问题（按得分从高到低排序显示）
95
                如果 更新.询问：
96
                    打印("\n  ASKS:")
97
                    用于 级别 在 反向(列表(更新.询问[:10])):  # 十大请求
98
                        print(f"    {level.px:>12} | {level.sz:>12} | ({level.n} orders)")
99

100
                # 显示点差
101
                如果 更新.出价 和 update.询价：
102
                    best_bid = float(update.出价[0].px) 如果 更新.出价 else 0
103
                    best_ask = float(更新.询问[0].px) 如果 更新.询问 else 0
104
                    如果 best_bid 且 best_ask：
105
                        spread = 最佳卖价 - 最佳买价
106
                        spread_bps = (点差 / 最佳买价) * 10000 如果 best_bid > 0 else 0
107
                        打印(f"\n  {'─'*44}")
108
                        print(f"  SPREAD: {spread:.2f} ({spread_bps:.2f} bps)")
109
                        打印(f"  {'─'*44}")
110

111
                # 显示出价
112
                如果 更新.出价:
113
                    打印("\n  BIDS:")
114
                    用于 级别 在 update中。出价[:10]:  # 前10名出价
115
                        print(f"    {level.px:>12} | {level.sz:>12} | ({level.n} orders)")
116

117
                print(f"\n  Messages received: {msg_count}")
118

119
        除了 grpc。RpcError 作为 e:
120
            如果 e.代码() == grpc.状态码.DATA_LOSS 和 auto_reconnect：
121
                print(f"\n⚠️  Server reinitialized: {e.details()}")
122
                retry_count += 1
123
                if retry_count < max_retries:
124
                    延迟 = base_delay * (2 ** (重试次数 - 1))  # 指数退避
125
                    打印(f"⏳ 正在等待 {延迟}秒后重新连接...")
126
                    时间.sleep(延迟)
127
                    频道.关闭()
128
                    继续
129
                else:
130
                    打印(f"\n❌ 最大重试次数 ({max_retries}) 已达到。放弃。")
131
                    换行
132
            else:
133
                print(f"\ngRPC error: {e.code()} - {e.details()}")
134
                换行
135
        除了 KeyboardInterrupt:
136
            打印("\n停止 L2 流...")
137
            换行
138
        最后:
139
            频道.关闭()
140

141
        # 如果在此处未出现错误，则退出重试循环
142
        换行
143

144

145
def main():
146
    解析器 = argparse.ArgumentParser(描述='通过 gRPC 流式传输Hyperliquid 订单簿数据gRPC)
147
    解析器.add_argument('--coin', 默认='BTC', 帮助='要直播的币种代码')
148
    解析器.add_argument('--levels', type=int, 默认值=20, 帮助='价格层级数量（默认：20，最大：100）')
149
    解析器.add_argument('--sig-figs', type=int, 默认值=None, 帮助='分桶法中的有效数字（2-5）')
150
    解析器.add_argument('--mantissa', type=int, 默认值=None, 帮助='分桶小数部分（1、2 或 5）')
151

152
    args = 解析器.parse_args()
153

154
    打印(f"\n{'='*60}")
155
    打印(Hyperliquid 示例”)
156
    print(f"Endpoint: {GRPC_ENDPOINT}")
157
    打印(f"{'='*60}")
158

159
    试一试：
160
        stream_l2_orderbook(参数.coin, n_levels=args.levels, n_sig_figs=args.sig_figs, 尾数=args.尾数)
161
    除 异常 作为 e:
162
        print(f"\nError: {e}")
163
        import traceback
164
        回溯.print_exc()
165
        sys.exit(1)
166

167

168
如果 __name__ == "__main__":
169
    主()
170

还没有账号吗？

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

免费开始使用