Add Binance announcement WebSocket support #750

0x0001 · 2025-08-29T07:18:48Z

How to use

func main() {
	client := binance.NewClient(os.Getenv("BINANCE_API_KEY"), os.Getenv("BINANCE_SECRET_KEY"))

	for range time.NewTicker(5 * time.Second).C {
		param, err := client.CreateAnnouncementParam()
		if err != nil {
			panic(err)
		}

		log.Println("start listen Announcement")
		doneC, _, err := binance.WsAnnouncementServe(param, func(event *binance.WsAnnouncementEvent) {
			log.Println("event", event)
		}, func(err error) {
			log.Println("has error", err)
		})

		if err != nil {
			log.Println(err)
		}
		log.Println("listen ok, wait message!")
		<-doneC
	}
}

Allows passing a ConnHandler to wsServeWithConnHandler for custom connection management, enabling active keepalive via ping messages. WsAnnouncementServe now uses this to send periodic pings.

carlosmiei · 2025-09-01T23:40:28Z

@0x0001 thanks a lot for your contribution, we will review and merge it soon!

Copilot

Pull Request Overview

This PR adds WebSocket support for Binance announcements, allowing clients to receive real-time announcement notifications from Binance's announcement system. This enables applications to stay updated with important Binance announcements such as delistings, new listings, and other platform updates.

Adds announcement WebSocket connection functionality with proper authentication
Implements keepalive mechanisms for WebSocket connections with both ping and pong handlers
Updates existing WebSocket infrastructure to support custom headers and connection handlers

Reviewed Changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 5 comments.

File	Description
v2/annouancement_service.go	Creates announcement parameters with proper authentication for WebSocket connection
v2/websocket.go	Enhances WebSocket infrastructure with header support and flexible keepalive mechanisms
v2/websocket_service.go	Implements announcement WebSocket service and updates type assertions to use 'any'
v2/websocket_service_test.go	Adds comprehensive tests for announcement WebSocket functionality

_{Tip: Customize your code reviews with copilot-instructions.md. Create the file or learn how to get started.}

v2/annouancement_service.go

v2/websocket_service.go

v2/annouancement_service.go

v2/websocket_service_test.go

sc0Vu · 2025-09-11T13:15:06Z

v2/websocket.go

-			keepAlive(c, WebsocketTimeout)
+
+		// Custom connection handling, useful in active keepalive scenarios
+		if connHandler != nil {


Why do you wrap keepalive in another connHandler? The connHandler isn't used in other place. How do you think we keep in the old way?

The websocket for the Binance announcement requires active ping messages. I want to put passive keepalive and active keepalive into one logic. The active keepalive is used in the WsAnouncementServe

sc0Vu · 2025-09-17T13:12:13Z

v2/websocket.go

+type ConnHandler func(context.Context, *websocket.Conn)
+
+// WsServeWithConnHandler serves websocket with custom connection handler, useful for custom keepalive
+var wsServeWithConnHandler = func(cfg *WsConfig, handler WsHandler, errHandler ErrHandler, connHandler ConnHandler) (doneC, stopC chan struct{}, err error) {


From the docs (https://developers.binance.com/docs/cms/general-info), looks like we need to send ping actively. wsServe seems to keep connection by replying ping from server. Does that work?

0x0001 · 2025-09-17T13:17:47Z

v2/websocket_service.go

+		handler(e)
+	}
+	return wsServeWithConnHandler(cfg, wsHandler, errHandler, keepAliveWithPing(30*time.Second, WebsocketTimeout))


@sc0Vu here, send ping actively, in the last arguments

I meant wsServe seems not used here. Should we remove it?

wsServe is used in other websocket services, do we need to change everything?

My bad, you're right.

sc0Vu · 2025-09-22T13:48:35Z

v2/websocket.go

+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				if err := c.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(WebsocketPongTimeout)); err != nil {


How do you think to add parameter WebsocketPingTimeout?

Can you be more specific? I don't get it.

sorry, i get it. What do you think about combining ping/pong timeout into WebSocketTimeout?

sc0Vu · 2025-09-22T13:50:55Z

v2/websocket.go

-			<-ticker.C
+	for {
+		select {
+		case <-ctx.Done():


Should we close the connection when context is cancelled?

The wsServeWithConnHandler code snippet is as follows

go func() { defer close(doneC) // 1 if connHandler != nil { ctx, cancel := context.WithCancel(context.Background()) defer cancel() // 2 go connHandler(ctx, c) } silent := false go func() { select { case <-stopC: silent = true case <-doneC: } c.Close() // 3 }() for { _, message, err := c.ReadMessage() if err != nil { if !silent { errHandler(err) } return } handler(message) } }()

// 2 go routine will only cause context cancel when it exits
// 1 If the go routine exits, it will execute close(doneC).
// 3 If doneC is closed, the websocket will be closed

This commit introduces atomic operations for tracking the last response time in websocket keepalive handlers, ensuring thread-safe access to the timestamp. It also adds a new `WebsocketKeepaliveTimeout` configuration variable to control the ping/pong message interval when keepalive is enabled, replacing the previous use of `WebsocketPongTimeout` for this purpose.

sc0Vu · 2025-09-23T08:58:29Z

v2/websocket_service.go

 	WebsocketTimeout = time.Second * 600
 	// WebsocketPongTimeout is an interval for sending a PONG frame in response to PING frame from server
 	WebsocketPongTimeout = time.Second * 10
+	// WebsocketKeepaliveTimeout is an interval for sending ping/pong messages if WebsocketKeepalive is enabled


We used WebsocketPongTimeout in other ws client, like delivery. IMHO, it's much easier to add WebsocketPingTimeout here. How do you think?

OK, Although I would have preferred to standardize on one variable, because when using it externally, you don't need to know whether the current websocket method is maintained by ping or pong, which is more cohesive. However, since the original variable has already been exported, changing the name of the variable directly will cause problems for users of the library.

The timeout variable names are now consistent with their actual usage: - WebsocketPingTimeout for PING frame deadlines - WebsocketPongTimeout for PONG frame deadlines This change affects both websocket.go and websocket_service.go files.

Copilot

Pull Request Overview

Copilot reviewed 4 out of 4 changed files in this pull request and generated 3 comments.

_{Tip: Customize your code reviews with copilot-instructions.md. Create the file or learn how to get started.}

Copilot · 2025-10-07T08:23:20Z

v2/websocket_service.go

 	WebsocketTimeout = time.Second * 600
 	// WebsocketPongTimeout is an interval for sending a PONG frame in response to PING frame from server
 	WebsocketPongTimeout = time.Second * 10
+	/// WebsocketPingTimeout is an interval for sending a PING frame in response to PONG frame from server


Incorrect comment format and description. Should use standard Go comment format with '//' and correct description: 'WebsocketPingTimeout is an interval for waiting for a PONG response after sending a PING frame'

Suggested change

/// WebsocketPingTimeout is an interval for sending a PING frame in response to PONG frame from server

// WebsocketPingTimeout is an interval for waiting for a PONG response after sending a PING frame

Copilot · 2025-10-07T08:23:20Z

v2/websocket_service.go

+		if event.Topic != "com_announcement_en" {
+			errHandler(errors.New("topic is not com_announcement_en: " + event.Topic))
+			return
+		}


Hard-coded topic string should be extracted as a constant to avoid duplication and improve maintainability. The same string 'com_announcement_en' is used in announcement_service.go line 45.

@sc0Vu This only repeats twice, and probably won't repeat more than that. I don't think it's necessary to define it as a constant. What's your take?

Copilot · 2025-10-07T08:23:20Z

v2/announcement_service.go

+		return WsAnnouncementParam{}, err
+	}
+	r := make([]byte, 16)
+	rand.Read(r)


The error from rand.Read should be checked. Although rand.Read from crypto/rand is documented to never return an error in practice, it's a security best practice to handle potential errors when generating cryptographic random values.

Suggested change

rand.Read(r)

if _, err := rand.Read(r); err != nil {

return WsAnnouncementParam{}, fmt.Errorf("failed to generate random bytes: %w", err)

}

0x0001 added 2 commits August 29, 2025 15:15

Add Binance announcement WebSocket support

d9bf299

Add custom connection handler for websocket keepalive

b70b844

Allows passing a ConnHandler to wsServeWithConnHandler for custom connection management, enabling active keepalive via ping messages. WsAnnouncementServe now uses this to send periodic pings.

0x0001 force-pushed the announcement branch from 099db8b to b70b844 Compare August 29, 2025 08:40

0x0001 added 3 commits August 29, 2025 17:12

Refactor websocket keepalive handling and improve pong timeout

395d12e

Refactor websocket keepalive functions for clarity and context handling

e0409a0

Refactor WsConfig Header to non-pointer and initialize by default

692bacd

carlosmiei requested a review from Copilot September 1, 2025 23:40

Copilot AI reviewed Sep 1, 2025

View reviewed changes

0x0001 added 2 commits September 3, 2025 09:07

Fix typos and improve error handling in announcement service

e43820e

Merge branch 'master' into announcement

ce42051

carlosmiei requested a review from sc0Vu September 10, 2025 14:21

sc0Vu reviewed Sep 11, 2025

View reviewed changes

sc0Vu reviewed Sep 17, 2025

View reviewed changes

0x0001 commented Sep 17, 2025

View reviewed changes

sc0Vu reviewed Sep 22, 2025

View reviewed changes

sc0Vu reviewed Sep 23, 2025

View reviewed changes

0x0001 force-pushed the announcement branch from 3d41c9e to 86649a8 Compare September 23, 2025 11:37

Use Set instead of Add for X-MBX-APIKEY header

f2bd8a7

carlosmiei requested a review from Copilot October 7, 2025 08:22

Copilot AI reviewed Oct 7, 2025

View reviewed changes

	/// WebsocketPingTimeout is an interval for sending a PING frame in response to PONG frame from server
	// WebsocketPingTimeout is an interval for waiting for a PONG response after sending a PING frame

-	rand.Read(r)
+	if _, err := rand.Read(r); err != nil {
+		return WsAnnouncementParam{}, fmt.Errorf("failed to generate random bytes: %w", err)
+	}

Add Binance announcement WebSocket support #750

Are you sure you want to change the base?

Add Binance announcement WebSocket support #750

Conversation

0x0001 commented Aug 29, 2025

Uh oh!

carlosmiei commented Sep 1, 2025

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull Request Overview

Reviewed Changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

0x0001 Sep 22, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull Request Overview

Uh oh!

Copilot AI Oct 7, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 7, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 7, 2025

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

0x0001 Sep 22, 2025 •

edited

Loading