StreamL2Book gRPC Method

이 방식은 데이터 사용량을 기준으로 0.0165 MB당 10 API 크레딧으로 과금된다는 점에 유의하시기 바랍니다.

매개변수

동전

문자열

로딩 중...

n_levels

uint32

로딩 중...

n_sig_figs

uint32

로딩 중...

mantissa

uint64

로딩 중...

반품

스트림

stream<L2BookUpdate>

로딩 중...

동전

문자열

로딩 중...

시간

uint64

로딩 중...

block_number

uint64

로딩 중...

bids

array<L2Level>

로딩 중...

asks

array<L2Level>

로딩 중...

요청

1
// StreamL2Book Example - Stream aggregated orderbook data via gRPC
2
패키지 main
3

4
import (
5
	"문맥"
6
	"깃발"
7
	"fmt"
8
	"io"
9
	"로그"
10
	"수학"
11
	"문자열"
12
	"시간"
13

14
	"google.golang.org/grpc"
15
	"google.golang.org/grpc/codes"
16
	"google.golang.org/grpc/credentials"
17
	"google.golang.org/grpc/metadata"
18
	"google.golang.org/grpc/status"
19

20
	pb "hyperliquid-orderbook-example/proto"
21
)
22

23
const (
24
	grpcEndpoint = "your-endpoint.hype-mainnet.quiknode.pro:10000"
25
	authToken    = "your-auth-token"
26
	maxRetries   = 10
27
	baseDelay    = 2 * time.초
28
)
29

30
func streamL2Orderbook(coin string, nLevels uint32) error {
31
	fmt.PrintlnPrintln문자열.반복("=", 60))
32
	fmt.Printf("Streaming L2 Orderbook for %s\n", coin)
33
	fmt.Printf("Levels: %d\n", nLevels)
34
	fmt.PrintlnPrintln ("자동 재연결: 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
			return fmt.Errorf("연결 실패: %w", err)
46
		}
47

48
		클라이언트 := pb.NewOrderBookStreamingClient)(conn)
49
		ctx := 메타데이터.AppendToOutgoingContext(컨텍스트.배경(), "x-token", authToken)
50

51
		request := &pb.L2BookRequest{
52
			Coin:    coin,
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", printf("%s에 연결 중...\n",)
60
		}
61

62
		stream, err := client.StreamL2Book(ctx, request)
63
		만약 err != nil {
64
			conn.닫기()
65
			return fmt.Errorf("스트림 시작에 실패했습니다: %w", err)
66
		}
67

68
		msgCount := 0
69
		shouldRetry := false
70

71
		~을 위해 {
72
			업데이트, 오류 := 스트림.Recv()
73
			만약 err == io.EOF {
74
				중단
75
			}
76
			만약 err != nil {
77
				st, 알겠습니다 := 상태.FromError(err)
78
				만약 ok && st.코드() == 코드.DataLoss {
79
					fmt.Printf("\n⚠️  서버 재초기화됨: %s\n", st.메시지())
80
					retryCount++
81
					if retryCount < maxRetries {
82
						지연 := 기본지연 * time.Duration(수학.Pow(2, float64(retryCount-1)))
83
						fmt.Printf("⏳ 재연결하기 전 %v 동안 대기 중...\n", delay)
84
						시간.수면(지연)
85
						shouldRetry = true
86
						중단
87
					} else {
88
						fmt.Printf("\n❌ 최대 재시도 횟수(%d)에 도달했습니다. 중단합니다.\n", maxRetries)
89
						conn.닫기()
90
						return nil
91
					}
92
				}
93
				conn.닫기()
94
				return fmt.Errorf("스트림 오류: %w", err)
95
			}
96

97
			msgCount++
98
			if msgCount == 1 {
99
				fmt.Println("✓ First L2 update received!\n")
100
				retryCount = 0 // 성공 시 재설정
101
			}
102

103
			// Display orderbook
104
			fmt.PrintlnPrintln ("\n" + strings.반복("─", 60))
105
			fmt.Printf("Block: %d | Time: %d | Coin: %s\n", update.BlockNumber, update.Time, update.Coin)
106
			fmt.PrintlnPrintln문자열.반복("─", 60))
107

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

121
			// Display spread
122
			if len(update.Bids) > 0 && len(update.Asks) > 0 {
123
				fmt.Println("\n  " + strings.Repeat("─", 44))
124
				fmt.Printf("  SPREAD: (best bid: %s, best ask: %s)\n", update.Bids[0].Px, update.Asks[0].Px)
125
				fmt.Println("  " + strings.Repeat("─", 44))
126
			}
127

128
			// Display bids
129
			if len(update.Bids) > 0 {
130
				fmt.Println("\n  BIDS:")
131
				bidCount := len(update.Bids)
132
				if bidCount > 10 {
133
					bidCount = 10
134
				}
135
				for i := 0; i < bidCount; i++ {
136
					level := update.Bids[i]
137
					fmt.Printf("    %12s | %12s | (%d orders)\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
	return nil
152
}
153

154
func main() {
155
	coin := flag.String("coin", "BTC", "Coin symbol to stream")
156
	levels := flag.Uint("levels", 20, "Number of price levels")
157

158
	깃발.구문 분석()
159

160
	fmt.PrintlnPrintln ("\n" + strings.반복("=", 60))
161
	fmt.Println("Hyperliquid StreamL2Book Example")
162
	fmt.Printf("엔드포인트: %s\n", grpcEndpoint)
163
	fmt.PrintlnPrintln문자열.반복("=", 60))
164

165
	if err := streamL2Orderbook(*coin, uint32(*levels)); err != nil {
166
		로그.치명적(err)
167
	}
168
}
169

1
// StreamL2Book Example - Stream aggregated orderbook data via gRPC
2
패키지 main
3

4
import (
5
	"문맥"
6
	"깃발"
7
	"fmt"
8
	"io"
9
	"로그"
10
	"수학"
11
	"문자열"
12
	"시간"
13

14
	"google.golang.org/grpc"
15
	"google.golang.org/grpc/codes"
16
	"google.golang.org/grpc/credentials"
17
	"google.golang.org/grpc/metadata"
18
	"google.golang.org/grpc/status"
19

20
	pb "hyperliquid-orderbook-example/proto"
21
)
22

23
const (
24
	grpcEndpoint = "your-endpoint.hype-mainnet.quiknode.pro:10000"
25
	authToken    = "your-auth-token"
26
	maxRetries   = 10
27
	baseDelay    = 2 * time.초
28
)
29

30
func streamL2Orderbook(coin string, nLevels uint32) error {
31
	fmt.PrintlnPrintln문자열.반복("=", 60))
32
	fmt.Printf("Streaming L2 Orderbook for %s\n", coin)
33
	fmt.Printf("Levels: %d\n", nLevels)
34
	fmt.PrintlnPrintln ("자동 재연결: 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
			return fmt.Errorf("연결 실패: %w", err)
46
		}
47

48
		클라이언트 := pb.NewOrderBookStreamingClient)(conn)
49
		ctx := 메타데이터.AppendToOutgoingContext(컨텍스트.배경(), "x-token", authToken)
50

51
		request := &pb.L2BookRequest{
52
			Coin:    coin,
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", printf("%s에 연결 중...\n",)
60
		}
61

62
		stream, err := client.StreamL2Book(ctx, request)
63
		만약 err != nil {
64
			conn.닫기()
65
			return fmt.Errorf("스트림 시작에 실패했습니다: %w", err)
66
		}
67

68
		msgCount := 0
69
		shouldRetry := false
70

71
		~을 위해 {
72
			업데이트, 오류 := 스트림.Recv()
73
			만약 err == io.EOF {
74
				중단
75
			}
76
			만약 err != nil {
77
				st, 알겠습니다 := 상태.FromError(err)
78
				만약 ok && st.코드() == 코드.DataLoss {
79
					fmt.Printf("\n⚠️  서버 재초기화됨: %s\n", st.메시지())
80
					retryCount++
81
					if retryCount < maxRetries {
82
						지연 := 기본지연 * time.Duration(수학.Pow(2, float64(retryCount-1)))
83
						fmt.Printf("⏳ 재연결하기 전 %v 동안 대기 중...\n", delay)
84
						시간.수면(지연)
85
						shouldRetry = true
86
						중단
87
					} else {
88
						fmt.Printf("\n❌ 최대 재시도 횟수(%d)에 도달했습니다. 중단합니다.\n", maxRetries)
89
						conn.닫기()
90
						return nil
91
					}
92
				}
93
				conn.닫기()
94
				return fmt.Errorf("스트림 오류: %w", err)
95
			}
96

97
			msgCount++
98
			if msgCount == 1 {
99
				fmt.Println("✓ First L2 update received!\n")
100
				retryCount = 0 // 성공 시 재설정
101
			}
102

103
			// Display orderbook
104
			fmt.PrintlnPrintln ("\n" + strings.반복("─", 60))
105
			fmt.Printf("Block: %d | Time: %d | Coin: %s\n", update.BlockNumber, update.Time, update.Coin)
106
			fmt.PrintlnPrintln문자열.반복("─", 60))
107

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

121
			// Display spread
122
			if len(update.Bids) > 0 && len(update.Asks) > 0 {
123
				fmt.Println("\n  " + strings.Repeat("─", 44))
124
				fmt.Printf("  SPREAD: (best bid: %s, best ask: %s)\n", update.Bids[0].Px, update.Asks[0].Px)
125
				fmt.Println("  " + strings.Repeat("─", 44))
126
			}
127

128
			// Display bids
129
			if len(update.Bids) > 0 {
130
				fmt.Println("\n  BIDS:")
131
				bidCount := len(update.Bids)
132
				if bidCount > 10 {
133
					bidCount = 10
134
				}
135
				for i := 0; i < bidCount; i++ {
136
					level := update.Bids[i]
137
					fmt.Printf("    %12s | %12s | (%d orders)\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
	return nil
152
}
153

154
func main() {
155
	coin := flag.String("coin", "BTC", "Coin symbol to stream")
156
	levels := flag.Uint("levels", 20, "Number of price levels")
157

158
	깃발.구문 분석()
159

160
	fmt.PrintlnPrintln ("\n" + strings.반복("=", 60))
161
	fmt.Println("Hyperliquid StreamL2Book Example")
162
	fmt.Printf("엔드포인트: %s\n", grpcEndpoint)
163
	fmt.PrintlnPrintln문자열.반복("=", 60))
164

165
	if err := streamL2Orderbook(*coin, uint32(*levels)); err != nil {
166
		로그.치명적(err)
167
	}
168
}
169

1
// StreamL2Book Example - Stream aggregated orderbook data via gRPC
2
const grpc = require('@grpc/grpc-js');
3
const protoLoader = require('@grpc/proto-loader');
4
const path = require('path');
5

6
const GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000';
7
const AUTH_TOKEN = 'your-auth-token';
8
const PROTO_PATH = path.join(__dirname, 'proto', 'orderbook.proto');
9

10
const 패키지 정의 = protoLoader.loadSync(PROTO_PATH, {
11
  keepCase: true,
12
  longs: String,
13
  열거형: String,
14
  기본값: true,
15
  oneofs: true
16
});
17
const proto = grpc.loadPackageDefinition(packageDefinition).hyperliquid;
18

19
함수 createClient() {
20
  돌아가기 new proto.OrderBookStreaming((
21
    GRPC_ENDPOINT,
22
    grpc.인증 정보.createSsl(),
23
    { 'grpc.max_receive_message_length': 100 * 1024 * 1024 }
24
  );
25
}
26

27
// Stream L2 (aggregated) orderbook
28
async function streamL2Orderbook(coin, nLevels = 20, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming L2 Orderbook for ${coin}`);
31
  console.log(`Levels: ${nLevels}`);
32
  console.log(`Auto-reconnect: ${autoReconnect}`);
33
  콘솔.log('='.반복(60) + '\n');
34

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

38
  while (retryCount < maxRetries) {
39
    const client = createClient();
40
    const 메타데이터 = new grpc.메타데이터();
41
    메타데이터.추가('x-token', AUTH_TOKEN);
42

43
    const request = {
44
      coin: coin,
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 call = client.StreamL2Book(request, metadata);
57

58
      호출.on('data', (업데이트) => {
59
        msgCount++;
60

61
        만약 (msgCount === 1) {
62
          console.log('✓ First L2 update received!\n');
63
          retryCount = 0; // 성공 시 재설정
64
        }
65

66
        콘솔.log('\n' + '─'.반복(60));
67
        console.log(`Block: ${update.block_number} | Time: ${update.time} | Coin: ${update.coin}`);
68
        콘솔.log('─'.반복(60));
69

70
        // Display asks (reversed for display)
71
        if (update.asks && update.asks.length > 0) {
72
          console.log('\n  ASKS:');
73
          update.asks.slice(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
        if (update.bids && update.bids.length > 0 && update.asks && update.asks.length > 0) {
80
          const bestBid = parseFloat(update.bids[0].px);
81
          const bestAsk = parseFloat(update.asks[0].px);
82
          const spread = bestAsk - bestBid;
83
          const spreadBps = (spread / bestBid) * 10000;
84
          console.log('\n  ' + '─'.repeat(44));
85
          console.log(`  SPREAD: ${spread.toFixed(2)} (${spreadBps.toFixed(2)} bps)`);
86
          console.log('  ' + '─'.repeat(44));
87
        }
88

89
        // Display bids
90
        if (update.bids && update.bids.length > 0) {
91
          console.log('\n  BIDS:');
92
          update.bids.slice(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
      호출.on('error', (err) => {
101
        만약 (err.코드 === grpc.상태.DATA_LOSS && autoReconnect) {
102
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
103
          retryCount++;
104
          if (retryCount < maxRetries) {
105
            const delay = baseDelay * Math.pow(2, retryCount - 1);
106
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
107
            setTimeout(() => streamL2Orderbook(coin, nLevels, autoReconnect, retryCount), delay);
108
          } else {
109
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
110
          }
111
        } else {
112
          콘솔.오류('\ngRPC 오류:', err.code, '-', err.메시지);
113
        }
114
      });
115

116
      호출.on('end', () => {
117
        콘솔.log('\n스트림 종료됨');
118
      });
119

120
      // Wait for stream to complete
121
      기다리다 새로운 약속((결심) => {
122
        호출.on('end', 해결);
123
        호출.on('error', 해결);
124
      });
125

126
      break; // 성공 시 재시도 루프 종료
127

128
    } catch (err) {
129
      콘솔.오류('오류:', err.message);
130
      break;
131
    }
132
  }
133
}
134

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

140
콘솔.log('\n' + '='.반복(60));
141
console.log('Hyperliquid StreamL2Book Example');
142
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
143
콘솔.log('='.반복(60));
144

145
streamL2Orderbook(coin, levels);
146

1
// StreamL2Book Example - Stream aggregated orderbook data via gRPC
2
const grpc = require('@grpc/grpc-js');
3
const protoLoader = require('@grpc/proto-loader');
4
const path = require('path');
5

6
const GRPC_ENDPOINT = 'your-endpoint.hype-mainnet.quiknode.pro:10000';
7
const AUTH_TOKEN = 'your-auth-token';
8
const PROTO_PATH = path.join(__dirname, 'proto', 'orderbook.proto');
9

10
const 패키지 정의 = protoLoader.loadSync(PROTO_PATH, {
11
  keepCase: true,
12
  longs: String,
13
  열거형: String,
14
  기본값: true,
15
  oneofs: true
16
});
17
const proto = grpc.loadPackageDefinition(packageDefinition).hyperliquid;
18

19
함수 createClient() {
20
  돌아가기 new proto.OrderBookStreaming((
21
    GRPC_ENDPOINT,
22
    grpc.인증 정보.createSsl(),
23
    { 'grpc.max_receive_message_length': 100 * 1024 * 1024 }
24
  );
25
}
26

27
// Stream L2 (aggregated) orderbook
28
async function streamL2Orderbook(coin, nLevels = 20, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming L2 Orderbook for ${coin}`);
31
  console.log(`Levels: ${nLevels}`);
32
  console.log(`Auto-reconnect: ${autoReconnect}`);
33
  콘솔.log('='.반복(60) + '\n');
34

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

38
  while (retryCount < maxRetries) {
39
    const client = createClient();
40
    const 메타데이터 = new grpc.메타데이터();
41
    메타데이터.추가('x-token', AUTH_TOKEN);
42

43
    const request = {
44
      coin: coin,
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 call = client.StreamL2Book(request, metadata);
57

58
      호출.on('data', (업데이트) => {
59
        msgCount++;
60

61
        만약 (msgCount === 1) {
62
          console.log('✓ First L2 update received!\n');
63
          retryCount = 0; // 성공 시 재설정
64
        }
65

66
        콘솔.log('\n' + '─'.반복(60));
67
        console.log(`Block: ${update.block_number} | Time: ${update.time} | Coin: ${update.coin}`);
68
        콘솔.log('─'.반복(60));
69

70
        // Display asks (reversed for display)
71
        if (update.asks && update.asks.length > 0) {
72
          console.log('\n  ASKS:');
73
          update.asks.slice(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
        if (update.bids && update.bids.length > 0 && update.asks && update.asks.length > 0) {
80
          const bestBid = parseFloat(update.bids[0].px);
81
          const bestAsk = parseFloat(update.asks[0].px);
82
          const spread = bestAsk - bestBid;
83
          const spreadBps = (spread / bestBid) * 10000;
84
          console.log('\n  ' + '─'.repeat(44));
85
          console.log(`  SPREAD: ${spread.toFixed(2)} (${spreadBps.toFixed(2)} bps)`);
86
          console.log('  ' + '─'.repeat(44));
87
        }
88

89
        // Display bids
90
        if (update.bids && update.bids.length > 0) {
91
          console.log('\n  BIDS:');
92
          update.bids.slice(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
      호출.on('error', (err) => {
101
        만약 (err.코드 === grpc.상태.DATA_LOSS && autoReconnect) {
102
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
103
          retryCount++;
104
          if (retryCount < maxRetries) {
105
            const delay = baseDelay * Math.pow(2, retryCount - 1);
106
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
107
            setTimeout(() => streamL2Orderbook(coin, nLevels, autoReconnect, retryCount), delay);
108
          } else {
109
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
110
          }
111
        } else {
112
          콘솔.오류('\ngRPC 오류:', err.code, '-', err.메시지);
113
        }
114
      });
115

116
      호출.on('end', () => {
117
        콘솔.log('\n스트림 종료됨');
118
      });
119

120
      // Wait for stream to complete
121
      기다리다 새로운 약속((결심) => {
122
        호출.on('end', 해결);
123
        호출.on('error', 해결);
124
      });
125

126
      break; // 성공 시 재시도 루프 종료
127

128
    } catch (err) {
129
      콘솔.오류('오류:', err.message);
130
      break;
131
    }
132
  }
133
}
134

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

140
콘솔.log('\n' + '='.반복(60));
141
console.log('Hyperliquid StreamL2Book Example');
142
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
143
콘솔.log('='.반복(60));
144

145
streamL2Orderbook(coin, levels);
146

1
#!/usr/bin/env python3
2
"""
3
StreamL2Book Example - Stream aggregated orderbook data via gRPC
4

5
설정:
6
    pip install grpcio grpcio-tools protobuf zstandard
7
    python -m grpc_tools.protoc -I../../proto --python_out=. --grpc_python_out=. ../../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
from typing import Optional
18

19
시도해 보세요:
20
    import orderbook_pb2 다음과 같이 pb
21
    import orderbook_pb2_grpc 다음과 같이 pb_grpc
22
except ImportError:
23
    인쇄("오류: Proto 파일이 생성되지 않았습니다. 다음을 실행하십시오:")
24
    인쇄("  python -m grpc_tools.protoc -I../../proto --python_out=. --grpc_python_out=. ../../proto/orderbook.proto")
25
    sys.exit(1)
26

27
# 구성
28
GRPC_ENDPOINT = "your-endpoint.hype-mainnet.quiknode.pro:10000"
29
AUTH_TOKEN = "your-auth-token"
30

31

32
def stream_l2_orderbook(coin: str, n_levels: int = 20, n_sig_figs: Optional[int] = None, mantissa: Optional[int] = None, auto_reconnect: bool = True):
33
    """
34
    Stream L2 (aggregated) orderbook updates for a coin.
35

36
    인수:
37
        coin: Symbol to stream (e.g., "BTC", "ETH")
38
        n_levels: Number of price levels to display (default 20, max 100)
39
        n_sig_figs: Significance figures for price bucketing (2-5)
40
        mantissa: Mantissa for bucketing (1, 2, or 5)
41
        auto_reconnect: DATA_LOSS 오류 발생 시 자동 재연결 (기본값: True)
42
    """
43
    인쇄(f"\n{'='*60}")
44
    print(f"Streaming L2 Orderbook for {coin}")
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_ENDPOINT,
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.OrderBookStreamingStub(채널)
63

64
        # 빌드 요청
65
        request = pb.L2BookRequest(
66
            coin=coin,
67
            n_levels=n_levels
68
        )
69
        if n_sig_figs is not None:
70
            request.n_sig_figs = n_sig_figs
71
        if mantissa is not None:
72
            request.mantissa = mantissa
73

74
        msg_count = 0
75

76
        시도해 보세요:
77
            if retry_count > 0:
78
                인쇄(f"\n🔄 다시 연결 중 (시도 중 {재시도 횟수 + 1}/{최대 재시도 횟수})...")
79
            else:
80
                인쇄(f"연결 중 {GRPC_ENDPOINT}...")
81

82
            for update in stub.StreamL2Book(request, metadata=[('x-token', AUTH_TOKEN)]):
83
                msg_count += 1
84

85
                if msg_count == 1:
86
                    print(f"✓ First L2 update received!\n")
87
                    retry_count = 0  # 연결에 성공하면 재시도 횟수를 초기화합니다
88

89
                # Display the L2 orderbook
90
                인쇄(f"\n{'─'*60}")
91
                print(f"Block: {update.block_number} | Time: {update.time} | Coin: {update.coin}")
92
                인쇄(f"{'─'*60}")
93

94
                # Show asks (sorted highest to lowest for display)
95
                if update.asks:
96
                    print("\n  ASKS:")
97
                    for level in reversed(list(update.asks[:10])):  # Top 10 asks
98
                        print(f"    {level.px:>12} | {level.sz:>12} | ({level.n} orders)")
99

100
                # Show spread
101
                if update.bids and update.asks:
102
                    best_bid = float(update.bids[0].px) if update.bids else 0
103
                    best_ask = float(update.asks[0].px) if update.asks else 0
104
                    if best_bid and best_ask:
105
                        spread = best_ask - best_bid
106
                        spread_bps = (spread / best_bid) * 10000 if best_bid > 0 else 0
107
                        print(f"\n  {'─'*44}")
108
                        print(f"  SPREAD: {spread:.2f} ({spread_bps:.2f} bps)")
109
                        print(f"  {'─'*44}")
110

111
                # Show bids
112
                if update.bids:
113
                    print("\n  BIDS:")
114
                    for level in update.bids[:10]:  # Top 10 bids
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.StatusCode.DATA_LOSS 및 auto_reconnect:
121
                print(f"\n⚠️  Server reinitialized: {e.details()}")
122
                retry_count += 1
123
                if retry_count < max_retries:
124
                    지연 = 기본_지연 * (2 ** (retry_count - 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
            print("\nStopping L2 stream...")
137
            중단
138
        드디어:
139
            채널.닫기()
140

141
        # 오류 없이 여기까지 도달했다면, 재시도 루프를 종료한다
142
        중단
143

144

145
def main():
146
    parser = argparse.ArgumentParser(description='Stream Hyperliquid L2 orderbook data via gRPC')
147
    parser.add_argument('--coin', default='BTC', help='Coin symbol to stream')
148
    parser.add_argument('--levels', type=int, default=20, help='Number of price levels (default: 20, max: 100)')
149
    parser.add_argument('--sig-figs', type=int, default=None, help='Significance figures for bucketing (2-5)')
150
    parser.add_argument('--mantissa', type=int, default=None, help='Mantissa for bucketing (1, 2, or 5)')
151

152
    args = parser.parse_args()
153

154
    인쇄(f"\n{'='*60}")
155
    print("Hyperliquid StreamL2Book Example")
156
    print(f"Endpoint: {GRPC_ENDPOINT}")
157
    인쇄(f"{'='*60}")
158

159
    시도해 보세요:
160
        stream_l2_orderbook(args.coin, n_levels=args.levels, n_sig_figs=args.sig_figs, mantissa=args.mantissa)
161
    단, 예외 ~처럼 e:
162
        print(f"\nError: {e}")
163
        import 트레이스백
164
        트레이스백.print_exc()
165
        sys.exit(1)
166

167

168
if __name__ == "__main__":
169
    main()
170

1
#!/usr/bin/env python3
2
"""
3
StreamL2Book Example - Stream aggregated orderbook data via gRPC
4

5
설정:
6
    pip install grpcio grpcio-tools protobuf zstandard
7
    python -m grpc_tools.protoc -I../../proto --python_out=. --grpc_python_out=. ../../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
from typing import Optional
18

19
시도해 보세요:
20
    import orderbook_pb2 다음과 같이 pb
21
    import orderbook_pb2_grpc 다음과 같이 pb_grpc
22
except ImportError:
23
    인쇄("오류: Proto 파일이 생성되지 않았습니다. 다음을 실행하십시오:")
24
    인쇄("  python -m grpc_tools.protoc -I../../proto --python_out=. --grpc_python_out=. ../../proto/orderbook.proto")
25
    sys.exit(1)
26

27
# 구성
28
GRPC_ENDPOINT = "your-endpoint.hype-mainnet.quiknode.pro:10000"
29
AUTH_TOKEN = "your-auth-token"
30

31

32
def stream_l2_orderbook(coin: str, n_levels: int = 20, n_sig_figs: Optional[int] = None, mantissa: Optional[int] = None, auto_reconnect: bool = True):
33
    """
34
    Stream L2 (aggregated) orderbook updates for a coin.
35

36
    인수:
37
        coin: Symbol to stream (e.g., "BTC", "ETH")
38
        n_levels: Number of price levels to display (default 20, max 100)
39
        n_sig_figs: Significance figures for price bucketing (2-5)
40
        mantissa: Mantissa for bucketing (1, 2, or 5)
41
        auto_reconnect: DATA_LOSS 오류 발생 시 자동 재연결 (기본값: True)
42
    """
43
    인쇄(f"\n{'='*60}")
44
    print(f"Streaming L2 Orderbook for {coin}")
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_ENDPOINT,
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.OrderBookStreamingStub(채널)
63

64
        # 빌드 요청
65
        request = pb.L2BookRequest(
66
            coin=coin,
67
            n_levels=n_levels
68
        )
69
        if n_sig_figs is not None:
70
            request.n_sig_figs = n_sig_figs
71
        if mantissa is not None:
72
            request.mantissa = mantissa
73

74
        msg_count = 0
75

76
        시도해 보세요:
77
            if retry_count > 0:
78
                인쇄(f"\n🔄 다시 연결 중 (시도 중 {재시도 횟수 + 1}/{최대 재시도 횟수})...")
79
            else:
80
                인쇄(f"연결 중 {GRPC_ENDPOINT}...")
81

82
            for update in stub.StreamL2Book(request, metadata=[('x-token', AUTH_TOKEN)]):
83
                msg_count += 1
84

85
                if msg_count == 1:
86
                    print(f"✓ First L2 update received!\n")
87
                    retry_count = 0  # 연결에 성공하면 재시도 횟수를 초기화합니다
88

89
                # Display the L2 orderbook
90
                인쇄(f"\n{'─'*60}")
91
                print(f"Block: {update.block_number} | Time: {update.time} | Coin: {update.coin}")
92
                인쇄(f"{'─'*60}")
93

94
                # Show asks (sorted highest to lowest for display)
95
                if update.asks:
96
                    print("\n  ASKS:")
97
                    for level in reversed(list(update.asks[:10])):  # Top 10 asks
98
                        print(f"    {level.px:>12} | {level.sz:>12} | ({level.n} orders)")
99

100
                # Show spread
101
                if update.bids and update.asks:
102
                    best_bid = float(update.bids[0].px) if update.bids else 0
103
                    best_ask = float(update.asks[0].px) if update.asks else 0
104
                    if best_bid and best_ask:
105
                        spread = best_ask - best_bid
106
                        spread_bps = (spread / best_bid) * 10000 if best_bid > 0 else 0
107
                        print(f"\n  {'─'*44}")
108
                        print(f"  SPREAD: {spread:.2f} ({spread_bps:.2f} bps)")
109
                        print(f"  {'─'*44}")
110

111
                # Show bids
112
                if update.bids:
113
                    print("\n  BIDS:")
114
                    for level in update.bids[:10]:  # Top 10 bids
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.StatusCode.DATA_LOSS 및 auto_reconnect:
121
                print(f"\n⚠️  Server reinitialized: {e.details()}")
122
                retry_count += 1
123
                if retry_count < max_retries:
124
                    지연 = 기본_지연 * (2 ** (retry_count - 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
            print("\nStopping L2 stream...")
137
            중단
138
        드디어:
139
            채널.닫기()
140

141
        # 오류 없이 여기까지 도달했다면, 재시도 루프를 종료한다
142
        중단
143

144

145
def main():
146
    parser = argparse.ArgumentParser(description='Stream Hyperliquid L2 orderbook data via gRPC')
147
    parser.add_argument('--coin', default='BTC', help='Coin symbol to stream')
148
    parser.add_argument('--levels', type=int, default=20, help='Number of price levels (default: 20, max: 100)')
149
    parser.add_argument('--sig-figs', type=int, default=None, help='Significance figures for bucketing (2-5)')
150
    parser.add_argument('--mantissa', type=int, default=None, help='Mantissa for bucketing (1, 2, or 5)')
151

152
    args = parser.parse_args()
153

154
    인쇄(f"\n{'='*60}")
155
    print("Hyperliquid StreamL2Book Example")
156
    print(f"Endpoint: {GRPC_ENDPOINT}")
157
    인쇄(f"{'='*60}")
158

159
    시도해 보세요:
160
        stream_l2_orderbook(args.coin, n_levels=args.levels, n_sig_figs=args.sig_figs, mantissa=args.mantissa)
161
    단, 예외 ~처럼 e:
162
        print(f"\nError: {e}")
163
        import 트레이스백
164
        트레이스백.print_exc()
165
        sys.exit(1)
166

167

168
if __name__ == "__main__":
169
    main()
170

아직 계정이 없으신가요?

단 몇 초 만에 Quicknode 엔드포인트를 생성하고 개발을 시작하세요

지금 무료로 시작하세요