StreamTpslUpdates gRPC 메서드

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

매개변수

동전

반복되는 문자열

로딩 중...

반품

스트림

stream<TpslUpdatesUpdate>

로딩 중...

시간

uint64

로딩 중...

높이

uint64

로딩 중...

스냅샷

bool

로딩 중...

diffs

array<TpslOrderDiff>

로딩 중...

요청

1
// StreamTpslUpdates Example - Stream TP/SL trigger-order 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
func streamTpslUpdates(coins []string) 오류 {
31
	fmt.PrintlnPrintln문자열.반복("=", 60))
32
	fmt.Printf("%s에 대한 TP/SL 업데이트 스트리밍\n", strings.Join(동전, ", "))
33
	fmt.PrintlnPrintln ("자동 재연결: true")
34
	fmt.PrintlnPrintln문자열.반복("=", 60) + "\n")
35

36
	retryCount := 0
37

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

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

50
		request := &pb.TpslUpdatesRequest{
51
			동전: 동전,
52
		}
53

54
		if retryCount > 0 {
55
			fmt.Printf("\n🔄 재연결 중 (시도 %d/%d)...\n", retryCount+1, maxRetries)
56
		} else {
57
			fmt.Printf("%s에 연결 중...\n", printf("%s에 연결 중...\n",)
58
		}
59

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

66
		msgCount := 0
67
		shouldRetry := false
68

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

95
			msgCount++
96
			if msgCount == 1 {
97
				fmt.Println("✓ 첫 번째 TP/SL 업데이트 수신!\n")
98
				retryCount = 0 // 성공 시 재설정
99
			}
100

101
			// Display update
102
			fmt.PrintlnPrintln ("\n" + strings.반복("─", 60))
103
			snapshotLabel := ""
104
			만약 업데이트.스냅샷 {
105
				스냅샷 레이블 = " | SNAPSHOT"
106
			}
107
			fmt.Printf("블록: %d | 시간: %d%s | 차이점: %d\n", update.높이, 업데이트.시간, 스냅샷 레이블, len(update.차이점))
108
			fmt.PrintlnPrintln문자열.반복("─", 60))
109

110
			for _, diff := range update.Diffs {
111
				side := "ASK"
112
				만약 diff.측면 == "B" {
113
					측면 = "BID"
114
				}
115
				sz := diff.Sz
116
				만약 diff.IsPositionTpsl {
117
					sz = "position-sized"
118
				}
119

120
				전환 diff.DiffType {
121
				사례 pb.TpslDiffType_TPSL_DIFF_TYPE_ADD:
122
					fmt.Printf("  ADD    %s oid: %d | %s | %s sz: %s\n", diff.Coin, diff.Oid, diff.OrderType, side, sz)
123
					fmt.Printf("         트리거: %s | 제한 픽셀: %s | 축소 전용: %t\n", diff.트리거 조건, diff.LimitPx, diff.ReduceOnly)
124
				사례 pb.TpslDiffType_TPSL_DIFF_TYPE_REMOVE:
125
					fmt.Printf("  %s 제거: %d | %s | 사유: %s\n", diff.코인, diff.Oid, diff.OrderType, diff.이유)
126
				}
127
			}
128

129
			fmt.Printf("\n  수신된 메시지: %d\n", msgCount)
130
		}
131

132
		conn.닫기()
133

134
		만약 !shouldRetry {
135
			중단
136
		}
137
	}
138

139
	return nil
140
}
141

142
func main() {
143
	coinsFlag := flag.String("coins", "ETH", "스트리밍할 코인 심볼을 쉼표로 구분하여 입력하세요 (예: ETH,BTC)")
144

145
	깃발.구문 분석()
146

147
	동전 := 문자열.Split(*coinsFlag, ",")
148

149
	fmt.PrintlnPrintln ("\n" + strings.반복("=", 60))
150
	fmt.Println("Hyperliquid StreamTpslUpdates 예제")
151
	fmt.Printf("엔드포인트: %s\n", grpcEndpoint)
152
	fmt.PrintlnPrintln문자열.반복("=", 60))
153

154
	if err := streamTpslUpdates(coins); err != nil {
155
		로그.치명적(err)
156
	}
157
}
158

1
// StreamTpslUpdates Example - Stream TP/SL trigger-order 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
func streamTpslUpdates(coins []string) 오류 {
31
	fmt.PrintlnPrintln문자열.반복("=", 60))
32
	fmt.Printf("%s에 대한 TP/SL 업데이트 스트리밍\n", strings.Join(동전, ", "))
33
	fmt.PrintlnPrintln ("자동 재연결: true")
34
	fmt.PrintlnPrintln문자열.반복("=", 60) + "\n")
35

36
	retryCount := 0
37

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

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

50
		request := &pb.TpslUpdatesRequest{
51
			동전: 동전,
52
		}
53

54
		if retryCount > 0 {
55
			fmt.Printf("\n🔄 재연결 중 (시도 %d/%d)...\n", retryCount+1, maxRetries)
56
		} else {
57
			fmt.Printf("%s에 연결 중...\n", printf("%s에 연결 중...\n",)
58
		}
59

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

66
		msgCount := 0
67
		shouldRetry := false
68

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

95
			msgCount++
96
			if msgCount == 1 {
97
				fmt.Println("✓ 첫 번째 TP/SL 업데이트 수신!\n")
98
				retryCount = 0 // 성공 시 재설정
99
			}
100

101
			// Display update
102
			fmt.PrintlnPrintln ("\n" + strings.반복("─", 60))
103
			snapshotLabel := ""
104
			만약 업데이트.스냅샷 {
105
				스냅샷 레이블 = " | SNAPSHOT"
106
			}
107
			fmt.Printf("블록: %d | 시간: %d%s | 차이점: %d\n", update.높이, 업데이트.시간, 스냅샷 레이블, len(update.차이점))
108
			fmt.PrintlnPrintln문자열.반복("─", 60))
109

110
			for _, diff := range update.Diffs {
111
				side := "ASK"
112
				만약 diff.측면 == "B" {
113
					측면 = "BID"
114
				}
115
				sz := diff.Sz
116
				만약 diff.IsPositionTpsl {
117
					sz = "position-sized"
118
				}
119

120
				전환 diff.DiffType {
121
				사례 pb.TpslDiffType_TPSL_DIFF_TYPE_ADD:
122
					fmt.Printf("  ADD    %s oid: %d | %s | %s sz: %s\n", diff.Coin, diff.Oid, diff.OrderType, side, sz)
123
					fmt.Printf("         트리거: %s | 제한 픽셀: %s | 축소 전용: %t\n", diff.트리거 조건, diff.LimitPx, diff.ReduceOnly)
124
				사례 pb.TpslDiffType_TPSL_DIFF_TYPE_REMOVE:
125
					fmt.Printf("  %s 제거: %d | %s | 사유: %s\n", diff.코인, diff.Oid, diff.OrderType, diff.이유)
126
				}
127
			}
128

129
			fmt.Printf("\n  수신된 메시지: %d\n", msgCount)
130
		}
131

132
		conn.닫기()
133

134
		만약 !shouldRetry {
135
			중단
136
		}
137
	}
138

139
	return nil
140
}
141

142
func main() {
143
	coinsFlag := flag.String("coins", "ETH", "스트리밍할 코인 심볼을 쉼표로 구분하여 입력하세요 (예: ETH,BTC)")
144

145
	깃발.구문 분석()
146

147
	동전 := 문자열.Split(*coinsFlag, ",")
148

149
	fmt.PrintlnPrintln ("\n" + strings.반복("=", 60))
150
	fmt.Println("Hyperliquid StreamTpslUpdates 예제")
151
	fmt.Printf("엔드포인트: %s\n", grpcEndpoint)
152
	fmt.PrintlnPrintln문자열.반복("=", 60))
153

154
	if err := streamTpslUpdates(coins); err != nil {
155
		로그.치명적(err)
156
	}
157
}
158

1
// StreamTpslUpdates Example - Stream TP/SL trigger-order 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 TP/SL trigger-order updates
28
async 함수 streamTpslUpdates(코인, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming TP/SL Updates for ${coins.length > 0 ? coins.join(', ') : 'all perp coins'}`);
31
  console.log(`Auto-reconnect: ${autoReconnect}`);
32
  콘솔.log('='.반복(60) + '\n');
33

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

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

42
    const request = {
43
      동전: 동전
44
    };
45

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

53
      let msgCount = 0;
54
      const 호출 = 클라이언트.StreamTpslUpdates(요청, 메타데이터);
55

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

59
        만약 (msgCount === 1) {
60
          콘솔.log('✓ 첫 번째 TP/SL 업데이트 수신!\n');
61
          retryCount = 0; // 성공 시 재설정
62
        }
63

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

68
        (업데이트.차이점 || []).forEach(diff => {
69
          const side = diff.side === 'B' ? 'BID' : 'ASK';
70
          const sz = diff.is_position_tpsl ? 'position-sized' : diff.sz;
71

72
          만약 (diff.diff_type === 'TPSL_DIFF_TYPE_ADD') {
73
            console.log(`  ADD    ${diff.coin} oid: ${diff.oid} | ${diff.order_type} | ${side} sz: ${sz}`);
74
            console.log(`         trigger: ${diff.trigger_condition} | limit px: ${diff.limit_px} | reduce-only: ${diff.reduce_only}`);
75
          } else if (diff.diff_type === 'TPSL_DIFF_TYPE_REMOVE') {
76
            console.log(`  REMOVE ${diff.coin} oid: ${diff.oid} | ${diff.order_type} | reason: ${diff.reason}`);
77
          }
78
        });
79

80
        console.log(`\n  Messages received: ${msgCount}`);
81
      });
82

83
      호출.on('error', (err) => {
84
        만약 (err.코드 === grpc.상태.DATA_LOSS && autoReconnect) {
85
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
86
          retryCount++;
87
          if (retryCount < maxRetries) {
88
            const delay = baseDelay * Math.pow(2, retryCount - 1);
89
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
90
            setTimeout(() => streamTpslUpdates(코인, autoReconnect, retryCount), delay);
91
          } else {
92
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
93
          }
94
        } else {
95
          콘솔.오류('\ngRPC 오류:', err.code, '-', err.메시지);
96
        }
97
      });
98

99
      호출.on('end', () => {
100
        콘솔.log('\n스트림 종료됨');
101
      });
102

103
      // Wait for stream to complete
104
      기다리다 새로운 약속((결심) => {
105
        호출.on('end', 해결);
106
        호출.on('error', 해결);
107
      });
108

109
      break; // 성공 시 재시도 루프 종료
110

111
    } catch (err) {
112
      콘솔.오류('오류:', err.message);
113
      break;
114
    }
115
  }
116
}
117

118
// Parse command line args
119
const args = process.argv.slice(2);
120
const 동전 = (args.find(a => a.startsWith('--coins='))?.split('=')[1] || 'ETH').분할(',');
121

122
콘솔.log('\n' + '='.반복(60));
123
콘솔.log('Hyperliquid StreamTpslUpdates 예제');
124
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
125
콘솔.log('='.반복(60));
126

127
streamTpslUpdates(코인);
128

1
// StreamTpslUpdates Example - Stream TP/SL trigger-order 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 TP/SL trigger-order updates
28
async 함수 streamTpslUpdates(코인, autoReconnect = true, retryCount = 0) {
29
  콘솔.log('='.반복(60));
30
  console.log(`Streaming TP/SL Updates for ${coins.length > 0 ? coins.join(', ') : 'all perp coins'}`);
31
  console.log(`Auto-reconnect: ${autoReconnect}`);
32
  콘솔.log('='.반복(60) + '\n');
33

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

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

42
    const request = {
43
      동전: 동전
44
    };
45

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

53
      let msgCount = 0;
54
      const 호출 = 클라이언트.StreamTpslUpdates(요청, 메타데이터);
55

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

59
        만약 (msgCount === 1) {
60
          콘솔.log('✓ 첫 번째 TP/SL 업데이트 수신!\n');
61
          retryCount = 0; // 성공 시 재설정
62
        }
63

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

68
        (업데이트.차이점 || []).forEach(diff => {
69
          const side = diff.side === 'B' ? 'BID' : 'ASK';
70
          const sz = diff.is_position_tpsl ? 'position-sized' : diff.sz;
71

72
          만약 (diff.diff_type === 'TPSL_DIFF_TYPE_ADD') {
73
            console.log(`  ADD    ${diff.coin} oid: ${diff.oid} | ${diff.order_type} | ${side} sz: ${sz}`);
74
            console.log(`         trigger: ${diff.trigger_condition} | limit px: ${diff.limit_px} | reduce-only: ${diff.reduce_only}`);
75
          } else if (diff.diff_type === 'TPSL_DIFF_TYPE_REMOVE') {
76
            console.log(`  REMOVE ${diff.coin} oid: ${diff.oid} | ${diff.order_type} | reason: ${diff.reason}`);
77
          }
78
        });
79

80
        console.log(`\n  Messages received: ${msgCount}`);
81
      });
82

83
      호출.on('error', (err) => {
84
        만약 (err.코드 === grpc.상태.DATA_LOSS && autoReconnect) {
85
          console.log(`\n⚠️  Server reinitialized: ${err.message}`);
86
          retryCount++;
87
          if (retryCount < maxRetries) {
88
            const delay = baseDelay * Math.pow(2, retryCount - 1);
89
            console.log(`⏳ Waiting ${delay / 1000}s before reconnecting...`);
90
            setTimeout(() => streamTpslUpdates(코인, autoReconnect, retryCount), delay);
91
          } else {
92
            console.log(`\n❌ Max retries (${maxRetries}) reached. Giving up.`);
93
          }
94
        } else {
95
          콘솔.오류('\ngRPC 오류:', err.code, '-', err.메시지);
96
        }
97
      });
98

99
      호출.on('end', () => {
100
        콘솔.log('\n스트림 종료됨');
101
      });
102

103
      // Wait for stream to complete
104
      기다리다 새로운 약속((결심) => {
105
        호출.on('end', 해결);
106
        호출.on('error', 해결);
107
      });
108

109
      break; // 성공 시 재시도 루프 종료
110

111
    } catch (err) {
112
      콘솔.오류('오류:', err.message);
113
      break;
114
    }
115
  }
116
}
117

118
// Parse command line args
119
const args = process.argv.slice(2);
120
const 동전 = (args.find(a => a.startsWith('--coins='))?.split('=')[1] || 'ETH').분할(',');
121

122
콘솔.log('\n' + '='.반복(60));
123
콘솔.log('Hyperliquid StreamTpslUpdates 예제');
124
console.log(`Endpoint: ${GRPC_ENDPOINT}`);
125
콘솔.log('='.반복(60));
126

127
streamTpslUpdates(코인);
128

1
#!/usr/bin/env python3
2
"""
3
StreamTpslUpdates 예제 - gRPC를 통한 스트림 TP/SL 트리거 순서 업데이트
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_tpsl_example.py --coins ETH,BTC
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_tpsl_updates(coins: list, auto_reconnect: bool = True):
32
    """
33
    하나 이상의 코인에 대한 TP/SL 발동 순서 업데이트를 스트리밍합니다.
34

35
    인수:
36
        코인: 스트리밍할 코인의 심볼(예: ["ETH", "BTC"]). 빈 목록은 모든 영구 코인을 의미합니다.
37
        auto_reconnect: DATA_LOSS 오류 발생 시 자동 재연결 (기본값: True)
38
    """
39
    인쇄(f"\n{'='*60}")
40
    인쇄(f"다음에 대한 TP/SL 업데이트 스트리밍 {', '.join(코인) if 코인 else '모든 퍼프 코인'}")
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
    while retry_count < max_retries:
49
        채널 = grpc.secure_channel(
50
            GRPC_ENDPOINT,
51
            grpc.ssl_channel_credentials(),
52
            옵션=[
53
                ('grpc.max_receive_message_length', 100 * 1024 * 1024),
54
                ('grpc.keepalive_time_ms', 30000),
55
            ]
56
        )
57
        스텁 = pb_grpc.OrderBookStreamingStub(채널)
58

59
        # 빌드 요청
60
        요청 = pb.TpslUpdatesRequest(코인=coins)
61

62
        msg_count = 0
63

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

70
            ~을 위해 업데이트 in 스텁.StreamTpslUpdates(요청, 메타데이터=[('x-token', AUTH_TOKEN)]):
71
                msg_count += 1
72

73
                if msg_count == 1:
74
                    인쇄(f"✓ 첫 번째 TP/SL 업데이트 수신!\n")
75
                    retry_count = 0  # 연결에 성공하면 재시도 횟수를 초기화합니다
76

77
                # 업데이트 내용 표시
78
                인쇄(f"\n{'─'*60}")
79
                snapshot_label = " | SNAPSHOT" if update.스냅샷 else ""
80
                print(f"Block: {update.height} | Time: {update.time}{snapshot_label} | Diffs: {len(update.diffs)}")
81
                인쇄(f"{'─'*60}")
82

83
                ~을 위해 diff in update.diffs:
84
                    측면 = "BID" if diff.side == "B" else "ASK"
85
                    sz = "position-sized" if diff.is_position_tpsl else diff.sz
86

87
                    만약 diff.diff_type == pb.TPSL_DIFF_TYPE_ADD:
88
                        print(f"  ADD    {diff.coin} oid: {diff.oid} | {diff.order_type} | {side} sz: {sz}")
89
                        print(f"         trigger: {diff.trigger_condition} | limit px: {diff.limit_px} | reduce-only: {diff.reduce_only}")
90
                    elif diff.diff_type == pb.TPSL_DIFF_TYPE_REMOVE:
91
                        print(f"  REMOVE {diff.coin} oid: {diff.oid} | {diff.order_type} | reason: {diff.reason}")
92

93
                print(f"\n  Messages received: {msg_count}")
94

95
        단, grpc.RpcError 를 e:
96
            만약 e.코드() == grpc.StatusCode.DATA_LOSS 및 auto_reconnect:
97
                print(f"\n⚠️  Server reinitialized: {e.details()}")
98
                retry_count += 1
99
                if retry_count < max_retries:
100
                    지연 = 기본_지연 * (2 ** (retry_count - 1))  # 지수적 백오프
101
                    인쇄(f"⏳ 대기 중 {지연}초 후 재연결됩니다...")
102
                    시간.sleep(지연)
103
                    채널.닫기()
104
                    계속
105
                else:
106
                    인쇄(f"\n❌ 최대 재시도 횟수 ({max_retries})에 도달했습니다. 중단합니다.")
107
                    중단
108
            else:
109
                print(f"\ngRPC error: {e.code()} - {e.details()}")
110
                중단
111
        단, KeyboardInterrupt:
112
            인쇄("\nTP/SL 스트림 중지 중...")
113
            중단
114
        드디어:
115
            채널.닫기()
116

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

120

121
def main():
122
    파서 = argparse.ArgumentParser(설명='gRPC를 통한 Stream Hyperliquid TP/SL 트리거 순서 업데이트')
123
    파서.add_argument('--coins', 기본값='ETH', 도움말='스트리밍할 코인 심볼을 쉼표로 구분하여 입력하세요 (예: ETH,BTC)')
124

125
    args = parser.parse_args()
126
    동전 = [c.strip() for c in args.coins.split(',') if c.strip()]
127

128
    인쇄(f"\n{'='*60}")
129
    인쇄("Hyperliquid StreamTpslUpdates 예제")
130
    print(f"Endpoint: {GRPC_ENDPOINT}")
131
    인쇄(f"{'='*60}")
132

133
    시도해 보세요:
134
        stream_tpsl_updates(코인)
135
    단, 예외 ~처럼 e:
136
        print(f"\nError: {e}")
137
        import 트레이스백
138
        트레이스백.print_exc()
139
        sys.exit(1)
140

141

142
if __name__ == "__main__":
143
    main()
144

1
#!/usr/bin/env python3
2
"""
3
StreamTpslUpdates 예제 - gRPC를 통한 스트림 TP/SL 트리거 순서 업데이트
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_tpsl_example.py --coins ETH,BTC
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_tpsl_updates(coins: list, auto_reconnect: bool = True):
32
    """
33
    하나 이상의 코인에 대한 TP/SL 발동 순서 업데이트를 스트리밍합니다.
34

35
    인수:
36
        코인: 스트리밍할 코인의 심볼(예: ["ETH", "BTC"]). 빈 목록은 모든 영구 코인을 의미합니다.
37
        auto_reconnect: DATA_LOSS 오류 발생 시 자동 재연결 (기본값: True)
38
    """
39
    인쇄(f"\n{'='*60}")
40
    인쇄(f"다음에 대한 TP/SL 업데이트 스트리밍 {', '.join(코인) if 코인 else '모든 퍼프 코인'}")
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
    while retry_count < max_retries:
49
        채널 = grpc.secure_channel(
50
            GRPC_ENDPOINT,
51
            grpc.ssl_channel_credentials(),
52
            옵션=[
53
                ('grpc.max_receive_message_length', 100 * 1024 * 1024),
54
                ('grpc.keepalive_time_ms', 30000),
55
            ]
56
        )
57
        스텁 = pb_grpc.OrderBookStreamingStub(채널)
58

59
        # 빌드 요청
60
        요청 = pb.TpslUpdatesRequest(코인=coins)
61

62
        msg_count = 0
63

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

70
            ~을 위해 업데이트 in 스텁.StreamTpslUpdates(요청, 메타데이터=[('x-token', AUTH_TOKEN)]):
71
                msg_count += 1
72

73
                if msg_count == 1:
74
                    인쇄(f"✓ 첫 번째 TP/SL 업데이트 수신!\n")
75
                    retry_count = 0  # 연결에 성공하면 재시도 횟수를 초기화합니다
76

77
                # 업데이트 내용 표시
78
                인쇄(f"\n{'─'*60}")
79
                snapshot_label = " | SNAPSHOT" if update.스냅샷 else ""
80
                print(f"Block: {update.height} | Time: {update.time}{snapshot_label} | Diffs: {len(update.diffs)}")
81
                인쇄(f"{'─'*60}")
82

83
                ~을 위해 diff in update.diffs:
84
                    측면 = "BID" if diff.side == "B" else "ASK"
85
                    sz = "position-sized" if diff.is_position_tpsl else diff.sz
86

87
                    만약 diff.diff_type == pb.TPSL_DIFF_TYPE_ADD:
88
                        print(f"  ADD    {diff.coin} oid: {diff.oid} | {diff.order_type} | {side} sz: {sz}")
89
                        print(f"         trigger: {diff.trigger_condition} | limit px: {diff.limit_px} | reduce-only: {diff.reduce_only}")
90
                    elif diff.diff_type == pb.TPSL_DIFF_TYPE_REMOVE:
91
                        print(f"  REMOVE {diff.coin} oid: {diff.oid} | {diff.order_type} | reason: {diff.reason}")
92

93
                print(f"\n  Messages received: {msg_count}")
94

95
        단, grpc.RpcError 를 e:
96
            만약 e.코드() == grpc.StatusCode.DATA_LOSS 및 auto_reconnect:
97
                print(f"\n⚠️  Server reinitialized: {e.details()}")
98
                retry_count += 1
99
                if retry_count < max_retries:
100
                    지연 = 기본_지연 * (2 ** (retry_count - 1))  # 지수적 백오프
101
                    인쇄(f"⏳ 대기 중 {지연}초 후 재연결됩니다...")
102
                    시간.sleep(지연)
103
                    채널.닫기()
104
                    계속
105
                else:
106
                    인쇄(f"\n❌ 최대 재시도 횟수 ({max_retries})에 도달했습니다. 중단합니다.")
107
                    중단
108
            else:
109
                print(f"\ngRPC error: {e.code()} - {e.details()}")
110
                중단
111
        단, KeyboardInterrupt:
112
            인쇄("\nTP/SL 스트림 중지 중...")
113
            중단
114
        드디어:
115
            채널.닫기()
116

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

120

121
def main():
122
    파서 = argparse.ArgumentParser(설명='gRPC를 통한 Stream Hyperliquid TP/SL 트리거 순서 업데이트')
123
    파서.add_argument('--coins', 기본값='ETH', 도움말='스트리밍할 코인 심볼을 쉼표로 구분하여 입력하세요 (예: ETH,BTC)')
124

125
    args = parser.parse_args()
126
    동전 = [c.strip() for c in args.coins.split(',') if c.strip()]
127

128
    인쇄(f"\n{'='*60}")
129
    인쇄("Hyperliquid StreamTpslUpdates 예제")
130
    print(f"Endpoint: {GRPC_ENDPOINT}")
131
    인쇄(f"{'='*60}")
132

133
    시도해 보세요:
134
        stream_tpsl_updates(코인)
135
    단, 예외 ~처럼 e:
136
        print(f"\nError: {e}")
137
        import 트레이스백
138
        트레이스백.print_exc()
139
        sys.exit(1)
140

141

142
if __name__ == "__main__":
143
    main()
144

아직 계정이 없으신가요?

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

지금 무료로 시작하세요