StreamL4BookUpdates gRPC Method

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

매개변수

동전

반복되는 문자열

로딩 중...

반품

스트림

stream<L4BookUpdatesUpdate>

로딩 중...

시간

uint64

로딩 중...

높이

uint64

로딩 중...

스냅샷

bool

로딩 중...

diffs

array<L4OrderDiff>

로딩 중...

요청

1
// StreamL4BookUpdates Example - Stream typed per-order book updates 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
type localOrder struct {
31
	coin string
32
	user string
33
	side string
34
	px   string
35
	sz   string
36
}
37

38
func streamL4BookUpdates(coins []string) error {
39
	fmt.PrintlnPrintln문자열.반복("=", 60))
40
	fmt.Printf("Streaming L4 Book Updates for %s\n", strings.Join(coins, ", "))
41
	fmt.PrintlnPrintln ("자동 재연결: true")
42
	fmt.PrintlnPrintln문자열.반복("=", 60) + "\n")
43

44
	retryCount := 0
45

46
	// Simple local order map keyed by oid
47
	orders := make(map[uint64]localOrder)
48

49
	for retryCount < maxRetries {
50
		creds := 인증 정보.NewClientTLSFromCert(nil, "")
51
		conn, err := grpc.Dial(grpcEndpoint,
52
			grpc.WithTransportCredentials(creds),
53
			grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(100*1024*1024)))
54
		만약 err != nil {
55
			return fmt.Errorf("연결 실패: %w", err)
56
		}
57

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

61
		request := &pb.L4BookUpdatesRequest{
62
			동전: 동전,
63
		}
64

65
		if retryCount > 0 {
66
			fmt.Printf("\n🔄 재연결 중 (시도 %d/%d)...\n", retryCount+1, maxRetries)
67
		} else {
68
			fmt.Printf("%s에 연결 중...\n", printf("%s에 연결 중...\n",)
69
		}
70

71
		stream, err := client.StreamL4BookUpdates(ctx, request)
72
		만약 err != nil {
73
			conn.닫기()
74
			return fmt.Errorf("스트림 시작에 실패했습니다: %w", err)
75
		}
76

77
		msgCount := 0
78
		shouldRetry := false
79

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

106
			msgCount++
107
			if msgCount == 1 {
108
				fmt.Println("✓ First L4 update received!\n")
109
				retryCount = 0 // 성공 시 재설정
110
			}
111

112
			만약 업데이트.스냅샷 {
113
				// Full reset snapshot: rebuild local state
114
				orders = make(map[uint64]localOrder)
115
			}
116

117
			// Display update
118
			fmt.PrintlnPrintln ("\n" + strings.반복("─", 60))
119
			snapshotLabel := ""
120
			만약 업데이트.스냅샷 {
121
				스냅샷 레이블 = " | SNAPSHOT"
122
			}
123
			fmt.Printf("블록: %d | 시간: %d%s | 차이점: %d\n", update.높이, 업데이트.시간, 스냅샷 레이블, len(update.차이점))
124
			fmt.PrintlnPrintln문자열.반복("─", 60))
125

126
			for _, diff := range update.Diffs {
127
				side := "ASK"
128
				만약 diff.측면 == "B" {
129
					측면 = "BID"
130
				}
131

132
				전환 diff.DiffType {
133
				case pb.L4OrderDiffType_L4_ORDER_DIFF_TYPE_NEW:
134
					orders[diff.Oid] = localOrder{coin: diff.Coin, user: diff.User, side: diff.Side, px: diff.Px, sz: diff.Sz}
135
					if !update.Snapshot {
136
						fmt.Printf("  NEW    %s oid: %d | %s %s x %s | %s\n", diff.Coin, diff.Oid, side, diff.Px, diff.Sz, diff.User)
137
					}
138
				case pb.L4OrderDiffType_L4_ORDER_DIFF_TYPE_UPDATE:
139
					if existing, ok := orders[diff.Oid]; ok {
140
						existing.sz = diff.Sz
141
						orders[diff.Oid] = existing
142
					}
143
					fmt.Printf("  UPDATE %s oid: %d | %s %s x %s | %s\n", diff.Coin, diff.Oid, side, diff.Px, diff.Sz, diff.User)
144
				case pb.L4OrderDiffType_L4_ORDER_DIFF_TYPE_REMOVE:
145
					delete(orders, diff.Oid)
146
					fmt.Printf("  REMOVE %s oid: %d | %s %s | %s\n", diff.Coin, diff.Oid, side, diff.Px, diff.User)
147
				}
148
			}
149

150
			fmt.Printf("\n  Resting orders tracked: %d | Messages received: %d\n", len(orders), msgCount)
151
		}
152

153
		conn.닫기()
154

155
		만약 !shouldRetry {
156
			중단
157
		}
158
	}
159

160
	return nil
161
}
162

163
func main() {
164
	coinsFlag := flag.String("coins", "BTC", "Comma-separated coin symbols to stream (e.g., BTC,ETH)")
165

166
	깃발.구문 분석()
167

168
	동전 := 문자열.Split(*coinsFlag, ",")
169

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

175
	if err := streamL4BookUpdates(coins); err != nil {
176
		로그.치명적(err)
177
	}
178
}
179

1
// StreamL4BookUpdates Example - Stream typed per-order book updates 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
type localOrder struct {
31
	coin string
32
	user string
33
	side string
34
	px   string
35
	sz   string
36
}
37

38
func streamL4BookUpdates(coins []string) error {
39
	fmt.PrintlnPrintln문자열.반복("=", 60))
40
	fmt.Printf("Streaming L4 Book Updates for %s\n", strings.Join(coins, ", "))
41
	fmt.PrintlnPrintln ("자동 재연결: true")
42
	fmt.PrintlnPrintln문자열.반복("=", 60) + "\n")
43

44
	retryCount := 0
45

46
	// Simple local order map keyed by oid
47
	orders := make(map[uint64]localOrder)
48

49
	for retryCount < maxRetries {
50
		creds := 인증 정보.NewClientTLSFromCert(nil, "")
51
		conn, err := grpc.Dial(grpcEndpoint,
52
			grpc.WithTransportCredentials(creds),
53
			grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(100*1024*1024)))
54
		만약 err != nil {
55
			return fmt.Errorf("연결 실패: %w", err)
56
		}
57

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

61
		request := &pb.L4BookUpdatesRequest{
62
			동전: 동전,
63
		}
64

65
		if retryCount > 0 {
66
			fmt.Printf("\n🔄 재연결 중 (시도 %d/%d)...\n", retryCount+1, maxRetries)
67
		} else {
68
			fmt.Printf("%s에 연결 중...\n", printf("%s에 연결 중...\n",)
69
		}
70

71
		stream, err := client.StreamL4BookUpdates(ctx, request)
72
		만약 err != nil {
73
			conn.닫기()
74
			return fmt.Errorf("스트림 시작에 실패했습니다: %w", err)
75
		}
76

77
		msgCount := 0
78
		shouldRetry := false
79

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

106
			msgCount++
107
			if msgCount == 1 {
108
				fmt.Println("✓ First L4 update received!\n")
109
				retryCount = 0 // 성공 시 재설정
110
			}
111

112
			만약 업데이트.스냅샷 {
113
				// Full reset snapshot: rebuild local state
114
				orders = make(map[uint64]localOrder)
115
			}
116

117
			// Display update
118
			fmt.PrintlnPrintln ("\n" + strings.반복("─", 60))
119
			snapshotLabel := ""
120
			만약 업데이트.스냅샷 {
121
				스냅샷 레이블 = " | SNAPSHOT"
122
			}
123
			fmt.Printf("블록: %d | 시간: %d%s | 차이점: %d\n", update.높이, 업데이트.시간, 스냅샷 레이블, len(update.차이점))
124
			fmt.PrintlnPrintln문자열.반복("─", 60))
125

126
			for _, diff := range update.Diffs {
127
				side := "ASK"
128
				만약 diff.측면 == "B" {
129
					측면 = "BID"
130
				}
131

132
				전환 diff.DiffType {
133
				case pb.L4OrderDiffType_L4_ORDER_DIFF_TYPE_NEW:
134
					orders[diff.Oid] = localOrder{coin: diff.Coin, user: diff.User, side: diff.Side, px: diff.Px, sz: diff.Sz}
135
					if !update.Snapshot {
136
						fmt.Printf("  NEW    %s oid: %d | %s %s x %s | %s\n", diff.Coin, diff.Oid, side, diff.Px, diff.Sz, diff.User)
137
					}
138
				case pb.L4OrderDiffType_L4_ORDER_DIFF_TYPE_UPDATE:
139
					if existing, ok := orders[diff.Oid]; ok {
140
						existing.sz = diff.Sz
141
						orders[diff.Oid] = existing
142
					}
143
					fmt.Printf("  UPDATE %s oid: %d | %s %s x %s | %s\n", diff.Coin, diff.Oid, side, diff.Px, diff.Sz, diff.User)
144
				case pb.L4OrderDiffType_L4_ORDER_DIFF_TYPE_REMOVE:
145
					delete(orders, diff.Oid)
146
					fmt.Printf("  REMOVE %s oid: %d | %s %s | %s\n", diff.Coin, diff.Oid, side, diff.Px, diff.User)
147
				}
148
			}
149

150
			fmt.Printf("\n  Resting orders tracked: %d | Messages received: %d\n", len(orders), msgCount)
151
		}
152

153
		conn.닫기()
154

155
		만약 !shouldRetry {
156
			중단
157
		}
158
	}
159

160
	return nil
161
}
162

163
func main() {
164
	coinsFlag := flag.String("coins", "BTC", "Comma-separated coin symbols to stream (e.g., BTC,ETH)")
165

166
	깃발.구문 분석()
167

168
	동전 := 문자열.Split(*coinsFlag, ",")
169

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

175
	if err := streamL4BookUpdates(coins); err != nil {
176
		로그.치명적(err)
177
	}
178
}
179

1
// StreamL4BookUpdates Example - Stream typed per-order book updates 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 typed per-order L4 book updates
28
async function streamL4BookUpdates(coins, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming L4 Book Updates for ${coins.length > 0 ? coins.join(', ') : 'all coins'}`);
31
  console.log(`Auto-reconnect: ${autoReconnect}`);
32
  콘솔.log('='.반복(60) + '\n');
33

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

37
  // Simple local order map keyed by oid
38
  const orders = new Map();
39

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

45
    const request = {
46
      동전: 동전
47
    };
48

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

56
      let msgCount = 0;
57
      const call = client.StreamL4BookUpdates(request, metadata);
58

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

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

67
        if (update.snapshot) {
68
          // Full reset snapshot: rebuild local state
69
          orders.clear();
70
        }
71

72
        콘솔.log('\n' + '─'.반복(60));
73
        console.log(`Block: ${update.height} | Time: ${update.time}${update.snapshot ? ' | SNAPSHOT' : ''} | Diffs: ${(update.diffs || []).length}`);
74
        콘솔.log('─'.반복(60));
75

76
        (업데이트.차이점 || []).forEach(diff => {
77
          switch (diff.diff_type) {
78
            case 'L4_ORDER_DIFF_TYPE_NEW':
79
              orders.set(diff.oid, { coin: diff.coin, user: diff.user, side: diff.side, px: diff.px, sz: diff.sz });
80
              if (!update.snapshot) {
81
                console.log(`  NEW    ${diff.coin} oid: ${diff.oid} | ${diff.side === 'B' ? 'BID' : 'ASK'} ${diff.px} x ${diff.sz} | ${diff.user}`);
82
              }
83
              break;
84
            case 'L4_ORDER_DIFF_TYPE_UPDATE':
85
              const existing = orders.get(diff.oid);
86
              if (existing) {
87
                existing.sz = diff.sz;
88
              }
89
              console.log(`  UPDATE ${diff.coin} oid: ${diff.oid} | ${diff.side === 'B' ? 'BID' : 'ASK'} ${diff.px} x ${diff.sz} | ${diff.user}`);
90
              break;
91
            case 'L4_ORDER_DIFF_TYPE_REMOVE':
92
              orders.delete(diff.oid);
93
              console.log(`  REMOVE ${diff.coin} oid: ${diff.oid} | ${diff.side === 'B' ? 'BID' : 'ASK'} ${diff.px} | ${diff.user}`);
94
              break;
95
          }
96
        });
97

98
        console.log(`\n  Resting orders tracked: ${orders.size} | Messages received: ${msgCount}`);
99
      });
100

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

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

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

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

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

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

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

145
streamL4BookUpdates(coins);
146

1
// StreamL4BookUpdates Example - Stream typed per-order book updates 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 typed per-order L4 book updates
28
async function streamL4BookUpdates(coins, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming L4 Book Updates for ${coins.length > 0 ? coins.join(', ') : 'all coins'}`);
31
  console.log(`Auto-reconnect: ${autoReconnect}`);
32
  콘솔.log('='.반복(60) + '\n');
33

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

37
  // Simple local order map keyed by oid
38
  const orders = new Map();
39

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

45
    const request = {
46
      동전: 동전
47
    };
48

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

56
      let msgCount = 0;
57
      const call = client.StreamL4BookUpdates(request, metadata);
58

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

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

67
        if (update.snapshot) {
68
          // Full reset snapshot: rebuild local state
69
          orders.clear();
70
        }
71

72
        콘솔.log('\n' + '─'.반복(60));
73
        console.log(`Block: ${update.height} | Time: ${update.time}${update.snapshot ? ' | SNAPSHOT' : ''} | Diffs: ${(update.diffs || []).length}`);
74
        콘솔.log('─'.반복(60));
75

76
        (업데이트.차이점 || []).forEach(diff => {
77
          switch (diff.diff_type) {
78
            case 'L4_ORDER_DIFF_TYPE_NEW':
79
              orders.set(diff.oid, { coin: diff.coin, user: diff.user, side: diff.side, px: diff.px, sz: diff.sz });
80
              if (!update.snapshot) {
81
                console.log(`  NEW    ${diff.coin} oid: ${diff.oid} | ${diff.side === 'B' ? 'BID' : 'ASK'} ${diff.px} x ${diff.sz} | ${diff.user}`);
82
              }
83
              break;
84
            case 'L4_ORDER_DIFF_TYPE_UPDATE':
85
              const existing = orders.get(diff.oid);
86
              if (existing) {
87
                existing.sz = diff.sz;
88
              }
89
              console.log(`  UPDATE ${diff.coin} oid: ${diff.oid} | ${diff.side === 'B' ? 'BID' : 'ASK'} ${diff.px} x ${diff.sz} | ${diff.user}`);
90
              break;
91
            case 'L4_ORDER_DIFF_TYPE_REMOVE':
92
              orders.delete(diff.oid);
93
              console.log(`  REMOVE ${diff.coin} oid: ${diff.oid} | ${diff.side === 'B' ? 'BID' : 'ASK'} ${diff.px} | ${diff.user}`);
94
              break;
95
          }
96
        });
97

98
        console.log(`\n  Resting orders tracked: ${orders.size} | Messages received: ${msgCount}`);
99
      });
100

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

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

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

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

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

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

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

145
streamL4BookUpdates(coins);
146

1
#!/usr/bin/env python3
2
"""
3
StreamL4BookUpdates Example - Stream typed per-order book updates 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_updates_example.py --coins BTC,ETH
11
"""
12

13
import grpc
14
import sys
15
import 시간
16
import argparse
17

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

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

30

31
def stream_l4_book_updates(coins: list, auto_reconnect: bool = True):
32
    """
33
    Stream typed per-order L4 book updates for one or more coins.
34

35
    인수:
36
        coins: Symbols to stream (e.g., ["BTC", "ETH"]). Empty list means all coins
37
        auto_reconnect: DATA_LOSS 오류 발생 시 자동 재연결 (기본값: True)
38
    """
39
    인쇄(f"\n{'='*60}")
40
    print(f"Streaming L4 Book Updates for {', '.join(coins) if coins else 'all coins'}")
41
    print(f"Auto-reconnect: {auto_reconnect}")
42
    인쇄(f"{'='*60}\n")
43

44
    retry_count = 0
45
    max_retries = 10
46
    base_delay = 2
47

48
    # Simple local order map keyed by oid
49
    orders = {}
50

51
    while retry_count < max_retries:
52
        채널 = grpc.secure_channel(
53
            GRPC_ENDPOINT,
54
            grpc.ssl_channel_credentials(),
55
            옵션=[
56
                ('grpc.max_receive_message_length', 100 * 1024 * 1024),
57
                ('grpc.keepalive_time_ms', 30000),
58
            ]
59
        )
60
        스텁 = pb_grpc.OrderBookStreamingStub(채널)
61

62
        # 빌드 요청
63
        request = pb.L4BookUpdatesRequest(coins=coins)
64

65
        msg_count = 0
66

67
        시도해 보세요:
68
            if retry_count > 0:
69
                인쇄(f"\n🔄 다시 연결 중 (시도 중 {재시도 횟수 + 1}/{최대 재시도 횟수})...")
70
            else:
71
                인쇄(f"연결 중 {GRPC_ENDPOINT}...")
72

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

76
                if msg_count == 1:
77
                    print(f"✓ First L4 update received!\n")
78
                    retry_count = 0  # 연결에 성공하면 재시도 횟수를 초기화합니다
79

80
                if update.snapshot:
81
                    # Full reset snapshot: rebuild local state
82
                    orders.clear()
83

84
                # 업데이트 내용 표시
85
                인쇄(f"\n{'─'*60}")
86
                snapshot_label = " | SNAPSHOT" if update.스냅샷 else ""
87
                print(f"Block: {update.height} | Time: {update.time}{snapshot_label} | Diffs: {len(update.diffs)}")
88
                인쇄(f"{'─'*60}")
89

90
                ~을 위해 diff in update.diffs:
91
                    측면 = "BID" if diff.side == "B" else "ASK"
92

93
                    if diff.diff_type == pb.L4_ORDER_DIFF_TYPE_NEW:
94
                        orders[diff.oid] = {"coin": diff.coin, "user": diff.user, "side": diff.side, "px": diff.px, "sz": diff.sz}
95
                        if not update.snapshot:
96
                            print(f"  NEW    {diff.coin} oid: {diff.oid} | {side} {diff.px} x {diff.sz} | {diff.user}")
97
                    elif diff.diff_type == pb.L4_ORDER_DIFF_TYPE_UPDATE:
98
                        if diff.oid in orders:
99
                            orders[diff.oid]["sz"] = diff.sz
100
                        print(f"  UPDATE {diff.coin} oid: {diff.oid} | {side} {diff.px} x {diff.sz} | {diff.user}")
101
                    elif diff.diff_type == pb.L4_ORDER_DIFF_TYPE_REMOVE:
102
                        orders.pop(diff.oid, None)
103
                        print(f"  REMOVE {diff.coin} oid: {diff.oid} | {side} {diff.px} | {diff.user}")
104

105
                print(f"\n  Resting orders tracked: {len(orders)} | Messages received: {msg_count}")
106

107
        단, grpc.RpcError 를 e:
108
            만약 e.코드() == grpc.StatusCode.DATA_LOSS 및 auto_reconnect:
109
                print(f"\n⚠️  Server reinitialized: {e.details()}")
110
                retry_count += 1
111
                if retry_count < max_retries:
112
                    지연 = 기본_지연 * (2 ** (retry_count - 1))  # 지수적 백오프
113
                    인쇄(f"⏳ 대기 중 {지연}초 후 재연결됩니다...")
114
                    시간.sleep(지연)
115
                    채널.닫기()
116
                    계속
117
                else:
118
                    인쇄(f"\n❌ 최대 재시도 횟수 ({max_retries})에 도달했습니다. 중단합니다.")
119
                    중단
120
            else:
121
                print(f"\ngRPC error: {e.code()} - {e.details()}")
122
                중단
123
        단, KeyboardInterrupt:
124
            print("\nStopping L4 updates stream...")
125
            중단
126
        드디어:
127
            채널.닫기()
128

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

132

133
def main():
134
    parser = argparse.ArgumentParser(description='Stream Hyperliquid typed per-order L4 book updates via gRPC')
135
    parser.add_argument('--coins', default='BTC', help='Comma-separated coin symbols to stream (e.g., BTC,ETH)')
136

137
    args = parser.parse_args()
138
    동전 = [c.strip() for c in args.coins.split(',') if c.strip()]
139

140
    인쇄(f"\n{'='*60}")
141
    print("Hyperliquid StreamL4BookUpdates Example")
142
    print(f"Endpoint: {GRPC_ENDPOINT}")
143
    인쇄(f"{'='*60}")
144

145
    시도해 보세요:
146
        stream_l4_book_updates(coins)
147
    단, 예외 ~처럼 e:
148
        print(f"\nError: {e}")
149
        import 트레이스백
150
        트레이스백.print_exc()
151
        sys.exit(1)
152

153

154
if __name__ == "__main__":
155
    main()
156

1
#!/usr/bin/env python3
2
"""
3
StreamL4BookUpdates Example - Stream typed per-order book updates 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_updates_example.py --coins BTC,ETH
11
"""
12

13
import grpc
14
import sys
15
import 시간
16
import argparse
17

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

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

30

31
def stream_l4_book_updates(coins: list, auto_reconnect: bool = True):
32
    """
33
    Stream typed per-order L4 book updates for one or more coins.
34

35
    인수:
36
        coins: Symbols to stream (e.g., ["BTC", "ETH"]). Empty list means all coins
37
        auto_reconnect: DATA_LOSS 오류 발생 시 자동 재연결 (기본값: True)
38
    """
39
    인쇄(f"\n{'='*60}")
40
    print(f"Streaming L4 Book Updates for {', '.join(coins) if coins else 'all coins'}")
41
    print(f"Auto-reconnect: {auto_reconnect}")
42
    인쇄(f"{'='*60}\n")
43

44
    retry_count = 0
45
    max_retries = 10
46
    base_delay = 2
47

48
    # Simple local order map keyed by oid
49
    orders = {}
50

51
    while retry_count < max_retries:
52
        채널 = grpc.secure_channel(
53
            GRPC_ENDPOINT,
54
            grpc.ssl_channel_credentials(),
55
            옵션=[
56
                ('grpc.max_receive_message_length', 100 * 1024 * 1024),
57
                ('grpc.keepalive_time_ms', 30000),
58
            ]
59
        )
60
        스텁 = pb_grpc.OrderBookStreamingStub(채널)
61

62
        # 빌드 요청
63
        request = pb.L4BookUpdatesRequest(coins=coins)
64

65
        msg_count = 0
66

67
        시도해 보세요:
68
            if retry_count > 0:
69
                인쇄(f"\n🔄 다시 연결 중 (시도 중 {재시도 횟수 + 1}/{최대 재시도 횟수})...")
70
            else:
71
                인쇄(f"연결 중 {GRPC_ENDPOINT}...")
72

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

76
                if msg_count == 1:
77
                    print(f"✓ First L4 update received!\n")
78
                    retry_count = 0  # 연결에 성공하면 재시도 횟수를 초기화합니다
79

80
                if update.snapshot:
81
                    # Full reset snapshot: rebuild local state
82
                    orders.clear()
83

84
                # 업데이트 내용 표시
85
                인쇄(f"\n{'─'*60}")
86
                snapshot_label = " | SNAPSHOT" if update.스냅샷 else ""
87
                print(f"Block: {update.height} | Time: {update.time}{snapshot_label} | Diffs: {len(update.diffs)}")
88
                인쇄(f"{'─'*60}")
89

90
                ~을 위해 diff in update.diffs:
91
                    측면 = "BID" if diff.side == "B" else "ASK"
92

93
                    if diff.diff_type == pb.L4_ORDER_DIFF_TYPE_NEW:
94
                        orders[diff.oid] = {"coin": diff.coin, "user": diff.user, "side": diff.side, "px": diff.px, "sz": diff.sz}
95
                        if not update.snapshot:
96
                            print(f"  NEW    {diff.coin} oid: {diff.oid} | {side} {diff.px} x {diff.sz} | {diff.user}")
97
                    elif diff.diff_type == pb.L4_ORDER_DIFF_TYPE_UPDATE:
98
                        if diff.oid in orders:
99
                            orders[diff.oid]["sz"] = diff.sz
100
                        print(f"  UPDATE {diff.coin} oid: {diff.oid} | {side} {diff.px} x {diff.sz} | {diff.user}")
101
                    elif diff.diff_type == pb.L4_ORDER_DIFF_TYPE_REMOVE:
102
                        orders.pop(diff.oid, None)
103
                        print(f"  REMOVE {diff.coin} oid: {diff.oid} | {side} {diff.px} | {diff.user}")
104

105
                print(f"\n  Resting orders tracked: {len(orders)} | Messages received: {msg_count}")
106

107
        단, grpc.RpcError 를 e:
108
            만약 e.코드() == grpc.StatusCode.DATA_LOSS 및 auto_reconnect:
109
                print(f"\n⚠️  Server reinitialized: {e.details()}")
110
                retry_count += 1
111
                if retry_count < max_retries:
112
                    지연 = 기본_지연 * (2 ** (retry_count - 1))  # 지수적 백오프
113
                    인쇄(f"⏳ 대기 중 {지연}초 후 재연결됩니다...")
114
                    시간.sleep(지연)
115
                    채널.닫기()
116
                    계속
117
                else:
118
                    인쇄(f"\n❌ 최대 재시도 횟수 ({max_retries})에 도달했습니다. 중단합니다.")
119
                    중단
120
            else:
121
                print(f"\ngRPC error: {e.code()} - {e.details()}")
122
                중단
123
        단, KeyboardInterrupt:
124
            print("\nStopping L4 updates stream...")
125
            중단
126
        드디어:
127
            채널.닫기()
128

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

132

133
def main():
134
    parser = argparse.ArgumentParser(description='Stream Hyperliquid typed per-order L4 book updates via gRPC')
135
    parser.add_argument('--coins', default='BTC', help='Comma-separated coin symbols to stream (e.g., BTC,ETH)')
136

137
    args = parser.parse_args()
138
    동전 = [c.strip() for c in args.coins.split(',') if c.strip()]
139

140
    인쇄(f"\n{'='*60}")
141
    print("Hyperliquid StreamL4BookUpdates Example")
142
    print(f"Endpoint: {GRPC_ENDPOINT}")
143
    인쇄(f"{'='*60}")
144

145
    시도해 보세요:
146
        stream_l4_book_updates(coins)
147
    단, 예외 ~처럼 e:
148
        print(f"\nError: {e}")
149
        import 트레이스백
150
        트레이스백.print_exc()
151
        sys.exit(1)
152

153

154
if __name__ == "__main__":
155
    main()
156

아직 계정이 없으신가요?

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

지금 무료로 시작하세요