StreamL4Book gRPC Method

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

매개변수

동전

문자열

로딩 중...

반품

스트림

stream<L4BookUpdate>

로딩 중...

스냅샷

L4BookSnapshot

로딩 중...

diff

L4BookDiff

로딩 중...

요청

1
// StreamL4Book Example - Stream individual order data via gRPC
2
패키지 main
3

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

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

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

24
const (
25
	grpcEndpoint = "your-endpoint.hype-mainnet.quiknode.pro:10000"
26
	authToken    = "your-auth-token"
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.PrintlnPrintln ("자동 재연결: 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
			return fmt.Errorf("연결 실패: %w", err)
47
		}
48

49
		클라이언트 := pb.NewOrderBookStreamingClient)(conn)
50
		ctx := 메타데이터.AppendToOutgoingContext(컨텍스트.배경(), "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", printf("%s에 연결 중...\n",)
60
		}
61

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

68
		snapshotReceived := false
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
			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
	return nil
192
}
193

194
func main() {
195
	coin := flag.String("coin", "BTC", "Coin symbol to stream")
196
	maxMessages := flag.Int("max-messages", 0, "Maximum messages (0 = unlimited)")
197

198
	깃발.구문 분석()
199

200
	fmt.PrintlnPrintln ("\n" + strings.반복("=", 60))
201
	fmt.Println("Hyperliquid StreamL4Book Example")
202
	fmt.Printf("엔드포인트: %s\n", grpcEndpoint)
203
	fmt.PrintlnPrintln문자열.반복("=", 60))
204

205
	if err := streamL4Orderbook(*coin, *maxMessages); err != nil {
206
		로그.치명적(err)
207
	}
208
}
209

1
// StreamL4Book Example - Stream individual order data via gRPC
2
패키지 main
3

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

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

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

24
const (
25
	grpcEndpoint = "your-endpoint.hype-mainnet.quiknode.pro:10000"
26
	authToken    = "your-auth-token"
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.PrintlnPrintln ("자동 재연결: 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
			return fmt.Errorf("연결 실패: %w", err)
47
		}
48

49
		클라이언트 := pb.NewOrderBookStreamingClient)(conn)
50
		ctx := 메타데이터.AppendToOutgoingContext(컨텍스트.배경(), "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", printf("%s에 연결 중...\n",)
60
		}
61

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

68
		snapshotReceived := false
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
			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
	return nil
192
}
193

194
func main() {
195
	coin := flag.String("coin", "BTC", "Coin symbol to stream")
196
	maxMessages := flag.Int("max-messages", 0, "Maximum messages (0 = unlimited)")
197

198
	깃발.구문 분석()
199

200
	fmt.PrintlnPrintln ("\n" + strings.반복("=", 60))
201
	fmt.Println("Hyperliquid StreamL4Book Example")
202
	fmt.Printf("엔드포인트: %s\n", grpcEndpoint)
203
	fmt.PrintlnPrintln문자열.반복("=", 60))
204

205
	if err := streamL4Orderbook(*coin, *maxMessages); err != nil {
206
		로그.치명적(err)
207
	}
208
}
209

1
// StreamL4Book Example - Stream individual order 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 L4 (individual orders) orderbook
28
async function streamL4Orderbook(coin, maxMessages = null, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming L4 Orderbook for ${coin}`);
31
  console.log(`Auto-reconnect: ${autoReconnect}`);
32
  콘솔.log('='.반복(60) + '\n');
33

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

38
  while (retryCount < maxRetries) {
39
    const client = 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
      호출.on('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
      호출.on('error', (err) => {
120
        만약 (err.코드 === grpc.상태.DATA_LOSS && autoReconnect) {
121
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
122
          retryCount++;
123
          if (retryCount < maxRetries) {
124
            const delay = 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.메시지);
132
        }
133
      });
134

135
      호출.on('end', () => {
136
        콘솔.log('\n스트림 종료됨');
137
      });
138

139
      // Wait for stream to complete
140
      기다리다 새로운 약속((결심) => {
141
        호출.on('end', 해결);
142
        호출.on('error', 해결);
143
      });
144

145
      break; // 성공 시 재시도 루프 종료
146

147
    } catch (err) {
148
      콘솔.오류('오류:', err.message);
149
      break;
150
    }
151
  }
152
}
153

154
// Parse command line args
155
const args = process.argv.slice(2);
156
const coin = 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
콘솔.log('\n' + '='.반복(60));
160
console.log('Hyperliquid StreamL4Book Example');
161
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
162
콘솔.log('='.반복(60));
163

164
streamL4Orderbook(coin, maxMessages);
165

1
// StreamL4Book Example - Stream individual order 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 L4 (individual orders) orderbook
28
async function streamL4Orderbook(coin, maxMessages = null, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming L4 Orderbook for ${coin}`);
31
  console.log(`Auto-reconnect: ${autoReconnect}`);
32
  콘솔.log('='.반복(60) + '\n');
33

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

38
  while (retryCount < maxRetries) {
39
    const client = 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
      호출.on('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
      호출.on('error', (err) => {
120
        만약 (err.코드 === grpc.상태.DATA_LOSS && autoReconnect) {
121
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
122
          retryCount++;
123
          if (retryCount < maxRetries) {
124
            const delay = 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.메시지);
132
        }
133
      });
134

135
      호출.on('end', () => {
136
        콘솔.log('\n스트림 종료됨');
137
      });
138

139
      // Wait for stream to complete
140
      기다리다 새로운 약속((결심) => {
141
        호출.on('end', 해결);
142
        호출.on('error', 해결);
143
      });
144

145
      break; // 성공 시 재시도 루프 종료
146

147
    } catch (err) {
148
      콘솔.오류('오류:', err.message);
149
      break;
150
    }
151
  }
152
}
153

154
// Parse command line args
155
const args = process.argv.slice(2);
156
const coin = 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
콘솔.log('\n' + '='.반복(60));
160
console.log('Hyperliquid StreamL4Book Example');
161
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
162
콘솔.log('='.반복(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 -m grpc_tools.protoc -I../../proto --python_out=. --grpc_python_out=. ../../proto/orderbook.proto
8

9
사용법:
10
    python stream_l4_example.py --coin BTC --max-messages 100
11
"""
12

13
import grpc
14
import json
15
import sys
16
import 시간
17
import argparse
18
from typing import Optional
19

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

28
# 구성
29
GRPC_ENDPOINT = "your-endpoint.hype-mainnet.quiknode.pro:10000"
30
AUTH_TOKEN = "your-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
        coin: Symbol to stream (e.g., "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_ENDPOINT,
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.OrderBookStreamingStub(채널)
62

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

65
        msg_count = 0
66
        snapshot_received = False
67

68
        시도해 보세요:
69
            if retry_count > 0:
70
                인쇄(f"\n🔄 다시 연결 중 (시도 중 {재시도 횟수 + 1}/{최대 재시도 횟수})...")
71
            else:
72
                인쇄(f"연결 중 {GRPC_ENDPOINT}...")
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.StatusCode.DATA_LOSS 및 auto_reconnect:
135
                print(f"\n⚠️  Server reinitialized: {e.details()}")
136
                retry_count += 1
137
                if retry_count < max_retries:
138
                    지연 = 기본_지연 * (2 ** (retry_count - 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
    parser.add_argument('--coin', default='BTC', help='Coin symbol to stream')
162
    parser.add_argument('--max-messages', type=int, default=None, help='Maximum number of messages to receive')
163

164
    args = parser.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 트레이스백
176
        트레이스백.print_exc()
177
        sys.exit(1)
178

179

180
if __name__ == "__main__":
181
    main()
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 -m grpc_tools.protoc -I../../proto --python_out=. --grpc_python_out=. ../../proto/orderbook.proto
8

9
사용법:
10
    python stream_l4_example.py --coin BTC --max-messages 100
11
"""
12

13
import grpc
14
import json
15
import sys
16
import 시간
17
import argparse
18
from typing import Optional
19

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

28
# 구성
29
GRPC_ENDPOINT = "your-endpoint.hype-mainnet.quiknode.pro:10000"
30
AUTH_TOKEN = "your-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
        coin: Symbol to stream (e.g., "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_ENDPOINT,
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.OrderBookStreamingStub(채널)
62

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

65
        msg_count = 0
66
        snapshot_received = False
67

68
        시도해 보세요:
69
            if retry_count > 0:
70
                인쇄(f"\n🔄 다시 연결 중 (시도 중 {재시도 횟수 + 1}/{최대 재시도 횟수})...")
71
            else:
72
                인쇄(f"연결 중 {GRPC_ENDPOINT}...")
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.StatusCode.DATA_LOSS 및 auto_reconnect:
135
                print(f"\n⚠️  Server reinitialized: {e.details()}")
136
                retry_count += 1
137
                if retry_count < max_retries:
138
                    지연 = 기본_지연 * (2 ** (retry_count - 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
    parser.add_argument('--coin', default='BTC', help='Coin symbol to stream')
162
    parser.add_argument('--max-messages', type=int, default=None, help='Maximum number of messages to receive')
163

164
    args = parser.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 트레이스백
176
        트레이스백.print_exc()
177
        sys.exit(1)
178

179

180
if __name__ == "__main__":
181
    main()
182

아직 계정이 없으신가요?

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

지금 무료로 시작하세요