StreamL2BookDiff gRPC Method

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

매개변수

동전

반복되는 문자열

로딩 중...

n_levels

uint32

로딩 중...

n_sig_figs

uint32

로딩 중...

mantissa

uint64

로딩 중...

skip_initial_snapshot

bool

로딩 중...

반품

스트림

stream<L2BookDiffUpdate>

로딩 중...

시간

uint64

로딩 중...

높이

uint64

로딩 중...

스냅샷

bool

로딩 중...

diffs

array<L2CoinDiff>

로딩 중...

요청

1
// StreamL2BookDiff Example - Stream incremental L2 price-level changes 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 streamL2BookDiff(coins []string, nLevels uint32) error {
31
	fmt.PrintlnPrintln문자열.반복("=", 60))
32
	fmt.Printf("Streaming L2 Book Diffs for %s\n", strings.Join(coins, ", "))
33
	fmt.Printf("Levels: %d\n", nLevels)
34
	fmt.PrintlnPrintln ("자동 재연결: true")
35
	fmt.PrintlnPrintln문자열.반복("=", 60) + "\n")
36

37
	retryCount := 0
38

39
	// Track last seq per coin for gap detection
40
	lastSeq := make(map[string]uint64)
41

42
	for retryCount < maxRetries {
43
		creds := 인증 정보.NewClientTLSFromCert(nil, "")
44
		conn, err := grpc.Dial(grpcEndpoint,
45
			grpc.WithTransportCredentials(creds),
46
			grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(100*1024*1024)))
47
		만약 err != nil {
48
			return fmt.Errorf("연결 실패: %w", err)
49
		}
50

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

54
		request := &pb.L2BookDiffRequest{
55
			Coins:   coins,
56
			NLevels: nLevels,
57
		}
58

59
		if retryCount > 0 {
60
			fmt.Printf("\n🔄 재연결 중 (시도 %d/%d)...\n", retryCount+1, maxRetries)
61
		} else {
62
			fmt.Printf("%s에 연결 중...\n", printf("%s에 연결 중...\n",)
63
		}
64

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

71
		msgCount := 0
72
		shouldRetry := false
73

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

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

106
			// Display diff update
107
			fmt.PrintlnPrintln ("\n" + strings.반복("─", 60))
108
			snapshotLabel := ""
109
			만약 업데이트.스냅샷 {
110
				스냅샷 레이블 = " | SNAPSHOT"
111
			}
112
			fmt.Printf("Block: %d | Time: %d%s\n", update.Height, update.Time, snapshotLabel)
113
			fmt.PrintlnPrintln문자열.반복("─", 60))
114

115
			for _, diff := range update.Diffs {
116
				// Check seq continuity per coin
117
				if prev, ok := lastSeq[diff.Coin]; ok && diff.PrevSeq != 0 && diff.PrevSeq != prev {
118
					fmt.Printf("  ⚠️  Sequence gap for %s: expected prev_seq %d, got %d\n", diff.Coin, prev, diff.PrevSeq)
119
				}
120
				lastSeq[diff.Coin] = diff.Seq
121

122
				label := "DIFF"
123
				if diff.Snapshot {
124
					label = "SNAPSHOT"
125
				}
126
				fmt.Printf("\n  %s [%s] seq: %d (prev: %d)\n", diff.Coin, label, diff.Seq, diff.PrevSeq)
127

128
				// Changed ask levels (sz "0" means level removed)
129
				for _, level := range diff.Asks {
130
					action := "SET"
131
					if level.Sz == "0" {
132
						action = "REMOVE"
133
					}
134
					fmt.Printf("    ASK %-6s %12s | %12s\n", action, level.Px, level.Sz)
135
				}
136

137
				// Changed bid levels
138
				for _, level := range diff.Bids {
139
					action := "SET"
140
					if level.Sz == "0" {
141
						action = "REMOVE"
142
					}
143
					fmt.Printf("    BID %-6s %12s | %12s\n", action, level.Px, level.Sz)
144
				}
145
			}
146

147
			fmt.Printf("\n  수신된 메시지: %d\n", msgCount)
148
		}
149

150
		conn.닫기()
151

152
		만약 !shouldRetry {
153
			중단
154
		}
155
	}
156

157
	return nil
158
}
159

160
func main() {
161
	coinsFlag := flag.String("coins", "BTC", "Comma-separated coin symbols to stream (e.g., BTC,ETH)")
162
	levels := flag.Uint("levels", 20, "Maximum price levels per side")
163

164
	깃발.구문 분석()
165

166
	동전 := 문자열.Split(*coinsFlag, ",")
167

168
	fmt.PrintlnPrintln ("\n" + strings.반복("=", 60))
169
	fmt.Println("Hyperliquid StreamL2BookDiff Example")
170
	fmt.Printf("엔드포인트: %s\n", grpcEndpoint)
171
	fmt.PrintlnPrintln문자열.반복("=", 60))
172

173
	if err := streamL2BookDiff(coins, uint32(*levels)); err != nil {
174
		로그.치명적(err)
175
	}
176
}
177

1
// StreamL2BookDiff Example - Stream incremental L2 price-level changes 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 streamL2BookDiff(coins []string, nLevels uint32) error {
31
	fmt.PrintlnPrintln문자열.반복("=", 60))
32
	fmt.Printf("Streaming L2 Book Diffs for %s\n", strings.Join(coins, ", "))
33
	fmt.Printf("Levels: %d\n", nLevels)
34
	fmt.PrintlnPrintln ("자동 재연결: true")
35
	fmt.PrintlnPrintln문자열.반복("=", 60) + "\n")
36

37
	retryCount := 0
38

39
	// Track last seq per coin for gap detection
40
	lastSeq := make(map[string]uint64)
41

42
	for retryCount < maxRetries {
43
		creds := 인증 정보.NewClientTLSFromCert(nil, "")
44
		conn, err := grpc.Dial(grpcEndpoint,
45
			grpc.WithTransportCredentials(creds),
46
			grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(100*1024*1024)))
47
		만약 err != nil {
48
			return fmt.Errorf("연결 실패: %w", err)
49
		}
50

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

54
		request := &pb.L2BookDiffRequest{
55
			Coins:   coins,
56
			NLevels: nLevels,
57
		}
58

59
		if retryCount > 0 {
60
			fmt.Printf("\n🔄 재연결 중 (시도 %d/%d)...\n", retryCount+1, maxRetries)
61
		} else {
62
			fmt.Printf("%s에 연결 중...\n", printf("%s에 연결 중...\n",)
63
		}
64

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

71
		msgCount := 0
72
		shouldRetry := false
73

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

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

106
			// Display diff update
107
			fmt.PrintlnPrintln ("\n" + strings.반복("─", 60))
108
			snapshotLabel := ""
109
			만약 업데이트.스냅샷 {
110
				스냅샷 레이블 = " | SNAPSHOT"
111
			}
112
			fmt.Printf("Block: %d | Time: %d%s\n", update.Height, update.Time, snapshotLabel)
113
			fmt.PrintlnPrintln문자열.반복("─", 60))
114

115
			for _, diff := range update.Diffs {
116
				// Check seq continuity per coin
117
				if prev, ok := lastSeq[diff.Coin]; ok && diff.PrevSeq != 0 && diff.PrevSeq != prev {
118
					fmt.Printf("  ⚠️  Sequence gap for %s: expected prev_seq %d, got %d\n", diff.Coin, prev, diff.PrevSeq)
119
				}
120
				lastSeq[diff.Coin] = diff.Seq
121

122
				label := "DIFF"
123
				if diff.Snapshot {
124
					label = "SNAPSHOT"
125
				}
126
				fmt.Printf("\n  %s [%s] seq: %d (prev: %d)\n", diff.Coin, label, diff.Seq, diff.PrevSeq)
127

128
				// Changed ask levels (sz "0" means level removed)
129
				for _, level := range diff.Asks {
130
					action := "SET"
131
					if level.Sz == "0" {
132
						action = "REMOVE"
133
					}
134
					fmt.Printf("    ASK %-6s %12s | %12s\n", action, level.Px, level.Sz)
135
				}
136

137
				// Changed bid levels
138
				for _, level := range diff.Bids {
139
					action := "SET"
140
					if level.Sz == "0" {
141
						action = "REMOVE"
142
					}
143
					fmt.Printf("    BID %-6s %12s | %12s\n", action, level.Px, level.Sz)
144
				}
145
			}
146

147
			fmt.Printf("\n  수신된 메시지: %d\n", msgCount)
148
		}
149

150
		conn.닫기()
151

152
		만약 !shouldRetry {
153
			중단
154
		}
155
	}
156

157
	return nil
158
}
159

160
func main() {
161
	coinsFlag := flag.String("coins", "BTC", "Comma-separated coin symbols to stream (e.g., BTC,ETH)")
162
	levels := flag.Uint("levels", 20, "Maximum price levels per side")
163

164
	깃발.구문 분석()
165

166
	동전 := 문자열.Split(*coinsFlag, ",")
167

168
	fmt.PrintlnPrintln ("\n" + strings.반복("=", 60))
169
	fmt.Println("Hyperliquid StreamL2BookDiff Example")
170
	fmt.Printf("엔드포인트: %s\n", grpcEndpoint)
171
	fmt.PrintlnPrintln문자열.반복("=", 60))
172

173
	if err := streamL2BookDiff(coins, uint32(*levels)); err != nil {
174
		로그.치명적(err)
175
	}
176
}
177

1
// StreamL2BookDiff Example - Stream incremental L2 price-level changes 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 incremental L2 book diffs
28
async function streamL2BookDiff(coins, nLevels = 20, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming L2 Book Diffs for ${coins.length > 0 ? coins.join(', ') : 'all coins'}`);
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
  // Track last seq per coin for gap detection
39
  const lastSeq = {};
40

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

46
    const request = {
47
      coins: coins,
48
      n_levels: nLevels
49
    };
50

51
    시도해 보세요 {
52
      만약 (retryCount > 0) {
53
        console.log(`\n🔄 Reconnecting (attempt ${retryCount + 1}/${maxRetries})...`);
54
      } else {
55
        console.log(`Connecting to ${GRPC_ENDPOINT}...`);
56
      }
57

58
      let msgCount = 0;
59
      const call = client.StreamL2BookDiff(request, metadata);
60

61
      호출.on('data', (업데이트) => {
62
        msgCount++;
63

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

69
        콘솔.log('\n' + '─'.반복(60));
70
        console.log(`Block: ${update.height} | Time: ${update.time}${update.snapshot ? ' | SNAPSHOT' : ''}`);
71
        콘솔.log('─'.반복(60));
72

73
        (업데이트.차이점 || []).forEach(diff => {
74
          // Check seq continuity per coin
75
          if (lastSeq[diff.coin] !== undefined && diff.prev_seq && String(diff.prev_seq) !== String(lastSeq[diff.coin])) {
76
            console.log(`  ⚠️  Sequence gap for ${diff.coin}: expected prev_seq ${lastSeq[diff.coin]}, got ${diff.prev_seq}`);
77
          }
78
          lastSeq[diff.coin] = diff.seq;
79

80
          const label = diff.snapshot ? 'SNAPSHOT' : 'DIFF';
81
          console.log(`\n  ${diff.coin} [${label}] seq: ${diff.seq} (prev: ${diff.prev_seq})`);
82

83
          // Changed ask levels (sz "0" means level removed)
84
          (diff.asks || []).forEach(level => {
85
            const action = level.sz === '0' ? 'REMOVE' : 'SET';
86
            console.log(`    ASK ${action.padEnd(6)} ${level.px.padStart(12)} | ${level.sz.padStart(12)}`);
87
          });
88

89
          // Changed bid levels
90
          (diff.bids || []).forEach(level => {
91
            const action = level.sz === '0' ? 'REMOVE' : 'SET';
92
            console.log(`    BID ${action.padEnd(6)} ${level.px.padStart(12)} | ${level.sz.padStart(12)}`);
93
          });
94
        });
95

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

99
      호출.on('error', (err) => {
100
        만약 (err.코드 === grpc.상태.DATA_LOSS && autoReconnect) {
101
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
102
          retryCount++;
103
          if (retryCount < maxRetries) {
104
            const delay = baseDelay * Math.pow(2, retryCount - 1);
105
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
106
            setTimeout(() => streamL2BookDiff(coins, nLevels, autoReconnect, retryCount), delay);
107
          } else {
108
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
109
          }
110
        } else {
111
          콘솔.오류('\ngRPC 오류:', err.code, '-', err.메시지);
112
        }
113
      });
114

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

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

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

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

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

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

144
streamL2BookDiff(coins, levels);
145

1
// StreamL2BookDiff Example - Stream incremental L2 price-level changes 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 incremental L2 book diffs
28
async function streamL2BookDiff(coins, nLevels = 20, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming L2 Book Diffs for ${coins.length > 0 ? coins.join(', ') : 'all coins'}`);
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
  // Track last seq per coin for gap detection
39
  const lastSeq = {};
40

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

46
    const request = {
47
      coins: coins,
48
      n_levels: nLevels
49
    };
50

51
    시도해 보세요 {
52
      만약 (retryCount > 0) {
53
        console.log(`\n🔄 Reconnecting (attempt ${retryCount + 1}/${maxRetries})...`);
54
      } else {
55
        console.log(`Connecting to ${GRPC_ENDPOINT}...`);
56
      }
57

58
      let msgCount = 0;
59
      const call = client.StreamL2BookDiff(request, metadata);
60

61
      호출.on('data', (업데이트) => {
62
        msgCount++;
63

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

69
        콘솔.log('\n' + '─'.반복(60));
70
        console.log(`Block: ${update.height} | Time: ${update.time}${update.snapshot ? ' | SNAPSHOT' : ''}`);
71
        콘솔.log('─'.반복(60));
72

73
        (업데이트.차이점 || []).forEach(diff => {
74
          // Check seq continuity per coin
75
          if (lastSeq[diff.coin] !== undefined && diff.prev_seq && String(diff.prev_seq) !== String(lastSeq[diff.coin])) {
76
            console.log(`  ⚠️  Sequence gap for ${diff.coin}: expected prev_seq ${lastSeq[diff.coin]}, got ${diff.prev_seq}`);
77
          }
78
          lastSeq[diff.coin] = diff.seq;
79

80
          const label = diff.snapshot ? 'SNAPSHOT' : 'DIFF';
81
          console.log(`\n  ${diff.coin} [${label}] seq: ${diff.seq} (prev: ${diff.prev_seq})`);
82

83
          // Changed ask levels (sz "0" means level removed)
84
          (diff.asks || []).forEach(level => {
85
            const action = level.sz === '0' ? 'REMOVE' : 'SET';
86
            console.log(`    ASK ${action.padEnd(6)} ${level.px.padStart(12)} | ${level.sz.padStart(12)}`);
87
          });
88

89
          // Changed bid levels
90
          (diff.bids || []).forEach(level => {
91
            const action = level.sz === '0' ? 'REMOVE' : 'SET';
92
            console.log(`    BID ${action.padEnd(6)} ${level.px.padStart(12)} | ${level.sz.padStart(12)}`);
93
          });
94
        });
95

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

99
      호출.on('error', (err) => {
100
        만약 (err.코드 === grpc.상태.DATA_LOSS && autoReconnect) {
101
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
102
          retryCount++;
103
          if (retryCount < maxRetries) {
104
            const delay = baseDelay * Math.pow(2, retryCount - 1);
105
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
106
            setTimeout(() => streamL2BookDiff(coins, nLevels, autoReconnect, retryCount), delay);
107
          } else {
108
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
109
          }
110
        } else {
111
          콘솔.오류('\ngRPC 오류:', err.code, '-', err.메시지);
112
        }
113
      });
114

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

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

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

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

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

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

144
streamL2BookDiff(coins, levels);
145

1
#!/usr/bin/env python3
2
"""
3
StreamL2BookDiff Example - Stream incremental L2 price-level changes 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_diff_example.py --coins BTC,ETH --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_book_diff(coins: list, n_levels: int = 20, n_sig_figs: Optional[int] = None, mantissa: Optional[int] = None, skip_initial_snapshot: bool = False, auto_reconnect: bool = True):
33
    """
34
    Stream incremental L2 price-level changes for one or more coins.
35

36
    인수:
37
        coins: Symbols to stream (e.g., ["BTC", "ETH"]). Empty list means all coins
38
        n_levels: Maximum number of price levels tracked per side (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
        skip_initial_snapshot: Skip the initial per-coin snapshot (default False)
42
        auto_reconnect: DATA_LOSS 오류 발생 시 자동 재연결 (기본값: True)
43
    """
44
    인쇄(f"\n{'='*60}")
45
    print(f"Streaming L2 Book Diffs for {', '.join(coins) if coins else 'all coins'}")
46
    print(f"Levels: {n_levels}")
47
    print(f"Auto-reconnect: {auto_reconnect}")
48
    인쇄(f"{'='*60}\n")
49

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

54
    # Track last seq per coin for gap detection
55
    last_seq = {}
56

57
    while retry_count < max_retries:
58
        채널 = grpc.secure_channel(
59
            GRPC_ENDPOINT,
60
            grpc.ssl_channel_credentials(),
61
            옵션=[
62
                ('grpc.max_receive_message_length', 100 * 1024 * 1024),
63
                ('grpc.keepalive_time_ms', 30000),
64
            ]
65
        )
66
        스텁 = pb_grpc.OrderBookStreamingStub(채널)
67

68
        # 빌드 요청
69
        request = pb.L2BookDiffRequest(
70
            coins=coins,
71
            n_levels=n_levels,
72
            skip_initial_snapshot=skip_initial_snapshot
73
        )
74
        if n_sig_figs is not None:
75
            request.n_sig_figs = n_sig_figs
76
        if mantissa is not None:
77
            request.mantissa = mantissa
78

79
        msg_count = 0
80

81
        시도해 보세요:
82
            if retry_count > 0:
83
                인쇄(f"\n🔄 다시 연결 중 (시도 중 {재시도 횟수 + 1}/{최대 재시도 횟수})...")
84
            else:
85
                인쇄(f"연결 중 {GRPC_ENDPOINT}...")
86

87
            for update in stub.StreamL2BookDiff(request, metadata=[('x-token', AUTH_TOKEN)]):
88
                msg_count += 1
89

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

94
                # Display the diff update
95
                인쇄(f"\n{'─'*60}")
96
                snapshot_label = " | SNAPSHOT" if update.스냅샷 else ""
97
                print(f"Block: {update.height} | Time: {update.time}{snapshot_label}")
98
                인쇄(f"{'─'*60}")
99

100
                ~을 위해 diff in update.diffs:
101
                    # Check seq continuity per coin
102
                    if diff.coin in last_seq and diff.prev_seq and diff.prev_seq != last_seq[diff.coin]:
103
                        print(f"  ⚠️  Sequence gap for {diff.coin}: expected prev_seq {last_seq[diff.coin]}, got {diff.prev_seq}")
104
                    last_seq[diff.coin] = diff.seq
105

106
                    label = "SNAPSHOT" if diff.snapshot else "DIFF"
107
                    print(f"\n  {diff.coin} [{label}] seq: {diff.seq} (prev: {diff.prev_seq})")
108

109
                    # Changed ask levels (sz "0" means level removed)
110
                    for level in diff.asks:
111
                        action = "REMOVE" if level.sz == "0" else "SET"
112
                        print(f"    ASK {action:<6} {level.px:>12} | {level.sz:>12}")
113

114
                    # Changed bid levels
115
                    for level in diff.bids:
116
                        action = "REMOVE" if level.sz == "0" else "SET"
117
                        print(f"    BID {action:<6} {level.px:>12} | {level.sz:>12}")
118

119
                print(f"\n  Messages received: {msg_count}")
120

121
        단, grpc.RpcError 를 e:
122
            만약 e.코드() == grpc.StatusCode.DATA_LOSS 및 auto_reconnect:
123
                print(f"\n⚠️  Server reinitialized: {e.details()}")
124
                retry_count += 1
125
                if retry_count < max_retries:
126
                    지연 = 기본_지연 * (2 ** (retry_count - 1))  # 지수적 백오프
127
                    인쇄(f"⏳ 대기 중 {지연}초 후 재연결됩니다...")
128
                    시간.sleep(지연)
129
                    채널.닫기()
130
                    계속
131
                else:
132
                    인쇄(f"\n❌ 최대 재시도 횟수 ({max_retries})에 도달했습니다. 중단합니다.")
133
                    중단
134
            else:
135
                print(f"\ngRPC error: {e.code()} - {e.details()}")
136
                중단
137
        단, KeyboardInterrupt:
138
            print("\nStopping L2 diff stream...")
139
            중단
140
        드디어:
141
            채널.닫기()
142

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

146

147
def main():
148
    parser = argparse.ArgumentParser(description='Stream Hyperliquid incremental L2 order book diffs via gRPC')
149
    parser.add_argument('--coins', default='BTC', help='Comma-separated coin symbols to stream (e.g., BTC,ETH)')
150
    parser.add_argument('--levels', type=int, default=20, help='Maximum price levels per side (default: 20, max: 100)')
151
    parser.add_argument('--sig-figs', type=int, default=None, help='Significance figures for bucketing (2-5)')
152
    parser.add_argument('--mantissa', type=int, default=None, help='Mantissa for bucketing (1, 2, or 5)')
153
    parser.add_argument('--skip-snapshot', action='store_true', help='Skip the initial per-coin snapshot')
154

155
    args = parser.parse_args()
156
    동전 = [c.strip() for c in args.coins.split(',') if c.strip()]
157

158
    인쇄(f"\n{'='*60}")
159
    print("Hyperliquid StreamL2BookDiff Example")
160
    print(f"Endpoint: {GRPC_ENDPOINT}")
161
    인쇄(f"{'='*60}")
162

163
    시도해 보세요:
164
        stream_l2_book_diff(coins, n_levels=args.levels, n_sig_figs=args.sig_figs, mantissa=args.mantissa, skip_initial_snapshot=args.skip_snapshot)
165
    단, 예외 ~처럼 e:
166
        print(f"\nError: {e}")
167
        import 트레이스백
168
        트레이스백.print_exc()
169
        sys.exit(1)
170

171

172
if __name__ == "__main__":
173
    main()
174

1
#!/usr/bin/env python3
2
"""
3
StreamL2BookDiff Example - Stream incremental L2 price-level changes 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_diff_example.py --coins BTC,ETH --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_book_diff(coins: list, n_levels: int = 20, n_sig_figs: Optional[int] = None, mantissa: Optional[int] = None, skip_initial_snapshot: bool = False, auto_reconnect: bool = True):
33
    """
34
    Stream incremental L2 price-level changes for one or more coins.
35

36
    인수:
37
        coins: Symbols to stream (e.g., ["BTC", "ETH"]). Empty list means all coins
38
        n_levels: Maximum number of price levels tracked per side (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
        skip_initial_snapshot: Skip the initial per-coin snapshot (default False)
42
        auto_reconnect: DATA_LOSS 오류 발생 시 자동 재연결 (기본값: True)
43
    """
44
    인쇄(f"\n{'='*60}")
45
    print(f"Streaming L2 Book Diffs for {', '.join(coins) if coins else 'all coins'}")
46
    print(f"Levels: {n_levels}")
47
    print(f"Auto-reconnect: {auto_reconnect}")
48
    인쇄(f"{'='*60}\n")
49

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

54
    # Track last seq per coin for gap detection
55
    last_seq = {}
56

57
    while retry_count < max_retries:
58
        채널 = grpc.secure_channel(
59
            GRPC_ENDPOINT,
60
            grpc.ssl_channel_credentials(),
61
            옵션=[
62
                ('grpc.max_receive_message_length', 100 * 1024 * 1024),
63
                ('grpc.keepalive_time_ms', 30000),
64
            ]
65
        )
66
        스텁 = pb_grpc.OrderBookStreamingStub(채널)
67

68
        # 빌드 요청
69
        request = pb.L2BookDiffRequest(
70
            coins=coins,
71
            n_levels=n_levels,
72
            skip_initial_snapshot=skip_initial_snapshot
73
        )
74
        if n_sig_figs is not None:
75
            request.n_sig_figs = n_sig_figs
76
        if mantissa is not None:
77
            request.mantissa = mantissa
78

79
        msg_count = 0
80

81
        시도해 보세요:
82
            if retry_count > 0:
83
                인쇄(f"\n🔄 다시 연결 중 (시도 중 {재시도 횟수 + 1}/{최대 재시도 횟수})...")
84
            else:
85
                인쇄(f"연결 중 {GRPC_ENDPOINT}...")
86

87
            for update in stub.StreamL2BookDiff(request, metadata=[('x-token', AUTH_TOKEN)]):
88
                msg_count += 1
89

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

94
                # Display the diff update
95
                인쇄(f"\n{'─'*60}")
96
                snapshot_label = " | SNAPSHOT" if update.스냅샷 else ""
97
                print(f"Block: {update.height} | Time: {update.time}{snapshot_label}")
98
                인쇄(f"{'─'*60}")
99

100
                ~을 위해 diff in update.diffs:
101
                    # Check seq continuity per coin
102
                    if diff.coin in last_seq and diff.prev_seq and diff.prev_seq != last_seq[diff.coin]:
103
                        print(f"  ⚠️  Sequence gap for {diff.coin}: expected prev_seq {last_seq[diff.coin]}, got {diff.prev_seq}")
104
                    last_seq[diff.coin] = diff.seq
105

106
                    label = "SNAPSHOT" if diff.snapshot else "DIFF"
107
                    print(f"\n  {diff.coin} [{label}] seq: {diff.seq} (prev: {diff.prev_seq})")
108

109
                    # Changed ask levels (sz "0" means level removed)
110
                    for level in diff.asks:
111
                        action = "REMOVE" if level.sz == "0" else "SET"
112
                        print(f"    ASK {action:<6} {level.px:>12} | {level.sz:>12}")
113

114
                    # Changed bid levels
115
                    for level in diff.bids:
116
                        action = "REMOVE" if level.sz == "0" else "SET"
117
                        print(f"    BID {action:<6} {level.px:>12} | {level.sz:>12}")
118

119
                print(f"\n  Messages received: {msg_count}")
120

121
        단, grpc.RpcError 를 e:
122
            만약 e.코드() == grpc.StatusCode.DATA_LOSS 및 auto_reconnect:
123
                print(f"\n⚠️  Server reinitialized: {e.details()}")
124
                retry_count += 1
125
                if retry_count < max_retries:
126
                    지연 = 기본_지연 * (2 ** (retry_count - 1))  # 지수적 백오프
127
                    인쇄(f"⏳ 대기 중 {지연}초 후 재연결됩니다...")
128
                    시간.sleep(지연)
129
                    채널.닫기()
130
                    계속
131
                else:
132
                    인쇄(f"\n❌ 최대 재시도 횟수 ({max_retries})에 도달했습니다. 중단합니다.")
133
                    중단
134
            else:
135
                print(f"\ngRPC error: {e.code()} - {e.details()}")
136
                중단
137
        단, KeyboardInterrupt:
138
            print("\nStopping L2 diff stream...")
139
            중단
140
        드디어:
141
            채널.닫기()
142

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

146

147
def main():
148
    parser = argparse.ArgumentParser(description='Stream Hyperliquid incremental L2 order book diffs via gRPC')
149
    parser.add_argument('--coins', default='BTC', help='Comma-separated coin symbols to stream (e.g., BTC,ETH)')
150
    parser.add_argument('--levels', type=int, default=20, help='Maximum price levels per side (default: 20, max: 100)')
151
    parser.add_argument('--sig-figs', type=int, default=None, help='Significance figures for bucketing (2-5)')
152
    parser.add_argument('--mantissa', type=int, default=None, help='Mantissa for bucketing (1, 2, or 5)')
153
    parser.add_argument('--skip-snapshot', action='store_true', help='Skip the initial per-coin snapshot')
154

155
    args = parser.parse_args()
156
    동전 = [c.strip() for c in args.coins.split(',') if c.strip()]
157

158
    인쇄(f"\n{'='*60}")
159
    print("Hyperliquid StreamL2BookDiff Example")
160
    print(f"Endpoint: {GRPC_ENDPOINT}")
161
    인쇄(f"{'='*60}")
162

163
    시도해 보세요:
164
        stream_l2_book_diff(coins, n_levels=args.levels, n_sig_figs=args.sig_figs, mantissa=args.mantissa, skip_initial_snapshot=args.skip_snapshot)
165
    단, 예외 ~처럼 e:
166
        print(f"\nError: {e}")
167
        import 트레이스백
168
        트레이스백.print_exc()
169
        sys.exit(1)
170

171

172
if __name__ == "__main__":
173
    main()
174

아직 계정이 없으신가요?

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

지금 무료로 시작하세요