websocket/gateio: Add request functions for websocket multi-connection [SPOT] (#1598)

* gateio: Add multi asset websocket support WIP. * meow * Add tests and shenanigans * integrate flushing and for enabling/disabling pairs from rpc shenanigans * some changes * linter: fixes strikes again. * Change name ConnectionAssociation -> ConnectionCandidate for better clarity on purpose. Change connections map to point to candidate to track subscriptions for future dynamic connections holder and drop struct ConnectionDetails. * Add subscription tests (state functional) * glorious:nits + proxy handling * Spelling * linter: fixerino * instead of nil, dont do nil. * clean up nils * cya nils * don't need to set URL or check if its running * stream match update * update tests * linter: fix * glorious: nits + handle context cancellations * stop ping handler routine leak * * Fix bug where reader routine on error that is not a disconnection error but websocket frame error or anything really makes the reader routine return and then connection never cycles and the buffer gets filled. * Handle reconnection via an errors.Is check which is simpler and in that scope allow for quick disconnect reconnect without waiting for connection cycle. * Dial now uses code from DialContext but just calls context.Background() * Don't allow reader to return on parse binary response error. Just output error and return a non nil response * Allow rollback on connect on any error across all connections * fix shadow jutsu * glorious/gk: nitters - adds in ws mock server * linter: fix * fix deadlock on connection as the previous channel had no reader and would hang connection reader for eternity. * glorious: whooops * gk: nits * Leak issue and edge case * Websocket: Add SendMessageReturnResponses * whooooooopsie * gk: nitssssss * Update exchanges/stream/stream_match.go Co-authored-by: Gareth Kirwan <gbjkirwan@gmail.com> * Update exchanges/stream/stream_match_test.go Co-authored-by: Gareth Kirwan <gbjkirwan@gmail.com> * linter: appease the linter gods * gk: nits * gk: drain brain * started * more changes before merge match pr * gateio: still building out * gateio: finish spot * fix up tests in gateio * Add tests for stream package * rm unused field * glorious: nits * rn files, specifically set function names to asset and offload routing to websocket type. * linter: fix * glorious: nits * add counter and update gateio * fix collision issue * Update exchanges/stream/websocket.go Co-authored-by: Scott <gloriousCode@users.noreply.github.com> * glorious: nits * add tests * linter: fix * After merge * Add error connection info * upgrade to upstream merge * Fix edge case where it does not reconnect made by an already closed connection * stream coverage * glorious: nits * glorious: nits removed asset error handling in stream package * linter: fix * rm block * Add basic readme * fix asset enabled flush cycle for multi connection * spella: fix * linter: fix * Add glorious suggestions, fix some race thing * reinstate name before any routine gets spawned * stop on error in mock tests * glorious: nits * glorious: nits found in CI build * Add test for drain, bumped wait times as there seems to be something happening on macos CI builds, used context.WithTimeout because its instant. * mutex across shutdown and connect for protection * lint: fix * test time withoffset, reinstate stop * fix whoops * const trafficCheckInterval; rm testmain * y * fix lint * bump time check window * stream: fix intermittant test failures while testing routines and remove code that is not needed. * spells * cant do what I did * protect race due to routine. * update testURL * use mock websocket connection instead of test URL's * linter: fix * remove url because its throwing errors on CI builds * connections drop all the time, don't need to worry about not being able to echo back ws data as it can be easily reviewed _test file side. * remove another superfluous url thats not really set up for this * spawn overwatch routine when there is no errors, inline checker instead of waiting for a time period, add sleep inline with echo handler as this is really quick and wanted to ensure that latency is handing correctly * linter: fixerino uperino * glorious: panix * linter: things * whoops * dont need to make consecutive Unix() calls * websocket: fix potential panic on error and no responses and adding waitForResponses * rm json parser and handle in json package instead * linter: fix * linter: fix again * * change field name OutboundRequestSignature to WrapperDefinedConnectionSignature for agnostic inbound and outbound connections. * change method name GetOutboundConnection to GetConnection for agnostic inbound and outbound connections. * drop outbound field map for improved performance just using a range and field check (less complex as well) * change field name connections to connectionToWrapper for better clarity * spells and magic and wands * glorious: nits * comparable check for signature * mv err var * glorious: nits and stuff * attempt to fix race * glorious: nits * gk: nits; engine log cleanup * gk: nits; OCD * gk: nits; move function change file names * gk: nits; 🚀 * gk: nits; convert variadic function and message inspection to interface and include a specific function for that handling so as to not need nil on every call * gk: nits; continued * gk: engine nits; rm loaded exchange * gk: nits; drop WebsocketLoginResponse * stream: Add match method EnsureMatchWithData * gk: nits; rn Inspect to IsFinal * gk: nits; rn to MessageFilter * linter: fix * gateio: update rate limit definitions (cherry-pick) * Add test and missing * Shared REST rate limit definitions with Websocket service, set lookup item to nil for systems that do not require rate limiting; add glorious nit * integrate rate limits for websocket trading spot * bitstamp: fix issue * glorious: nits * ch name and commentary * fix bug add test * rm a thing * fix test * Update engine/engine.go Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io> * thrasher: nits * Update exchanges/stream/stream_match_test.go Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io> * Update exchanges/stream/stream_match_test.go Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io> * GK: nits rn websocket functions * explicit function names for single to multi outbound orders * linter: fix --------- Co-authored-by: shazbert <ryan.oharareid@thrasher.io> Co-authored-by: Gareth Kirwan <gbjkirwan@gmail.com> Co-authored-by: Scott <gloriousCode@users.noreply.github.com> Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io>
2026-06-05 15:10:59 +00:00 · 2024-12-20 13:50:31 +11:00
parent 143e336c03
commit 50448ec6a0
23 changed files with 951 additions and 103 deletions
--- a/exchanges/gateio/gateio_types.go
+++ b/exchanges/gateio/gateio_types.go
@@ -2008,12 +2008,13 @@ type WsEventResponse struct {

 // WsResponse represents generalized websocket push data from the server.
 type WsResponse struct {
-	ID      int64           `json:"id"`
-	Time    types.Time      `json:"time"`
-	TimeMs  types.Time      `json:"time_ms"`
-	Channel string          `json:"channel"`
-	Event   string          `json:"event"`
-	Result  json.RawMessage `json:"result"`
+	ID        int64           `json:"id"`
+	Time      types.Time      `json:"time"`
+	TimeMs    types.Time      `json:"time_ms"`
+	Channel   string          `json:"channel"`
+	Event     string          `json:"event"`
+	Result    json.RawMessage `json:"result"`
+	RequestID string          `json:"request_id"`
 }

 // WsTicker websocket ticker information.
--- a/exchanges/gateio/gateio_websocket.go
+++ b/exchanges/gateio/gateio_websocket.go
@@ -97,6 +97,64 @@ func (g *Gateio) WsConnectSpot(ctx context.Context, conn stream.Connection) erro
 	return nil
 }

+// authenticateSpot sends an authentication message to the websocket connection
+func (g *Gateio) authenticateSpot(ctx context.Context, conn stream.Connection) error {
+	return g.websocketLogin(ctx, conn, "spot.login")
+}
+
+// websocketLogin authenticates the websocket connection
+func (g *Gateio) websocketLogin(ctx context.Context, conn stream.Connection, channel string) error {
+	if conn == nil {
+		return fmt.Errorf("%w: %T", common.ErrNilPointer, conn)
+	}
+
+	if channel == "" {
+		return errChannelEmpty
+	}
+
+	creds, err := g.GetCredentials(ctx)
+	if err != nil {
+		return err
+	}
+
+	tn := time.Now().Unix()
+	msg := "api\n" + channel + "\n" + "\n" + strconv.FormatInt(tn, 10)
+	mac := hmac.New(sha512.New, []byte(creds.Secret))
+	if _, err = mac.Write([]byte(msg)); err != nil {
+		return err
+	}
+	signature := hex.EncodeToString(mac.Sum(nil))
+
+	payload := WebsocketPayload{
+		RequestID: strconv.FormatInt(conn.GenerateMessageID(false), 10),
+		APIKey:    creds.Key,
+		Signature: signature,
+		Timestamp: strconv.FormatInt(tn, 10),
+	}
+
+	req := WebsocketRequest{Time: tn, Channel: channel, Event: "api", Payload: payload}
+
+	resp, err := conn.SendMessageReturnResponse(ctx, websocketRateLimitNotNeededEPL, req.Payload.RequestID, req)
+	if err != nil {
+		return err
+	}
+
+	var inbound WebsocketAPIResponse
+	if err := json.Unmarshal(resp, &inbound); err != nil {
+		return err
+	}
+
+	if inbound.Header.Status != "200" {
+		var wsErr WebsocketErrors
+		if err := json.Unmarshal(inbound.Data, &wsErr.Errors); err != nil {
+			return err
+		}
+		return fmt.Errorf("%s: %s", wsErr.Errors.Label, wsErr.Errors.Message)
+	}
+
+	return nil
+}
+
 func (g *Gateio) generateWsSignature(secret, event, channel string, t int64) (string, error) {
 	msg := "channel=" + channel + "&event=" + event + "&time=" + strconv.FormatInt(t, 10)
 	mac := hmac.New(sha512.New, []byte(secret))
@@ -109,21 +167,21 @@ func (g *Gateio) generateWsSignature(secret, event, channel string, t int64) (st
 // WsHandleSpotData handles spot data
 func (g *Gateio) WsHandleSpotData(_ context.Context, respRaw []byte) error {
 	var push WsResponse
-	err := json.Unmarshal(respRaw, &push)
-	if err != nil {
+	if err := json.Unmarshal(respRaw, &push); err != nil {
 		return err
 	}

+	if push.RequestID != "" {
+		return g.Websocket.Match.RequireMatchWithData(push.RequestID, respRaw)
+	}
+
 	if push.Event == subscribeEvent || push.Event == unsubscribeEvent {
-		if !g.Websocket.Match.IncomingWithData(push.ID, respRaw) {
-			return fmt.Errorf("couldn't match subscription message with ID: %d", push.ID)
-		}
-		return nil
+		return g.Websocket.Match.RequireMatchWithData(push.ID, respRaw)
 	}

 	switch push.Channel { // TODO: Convert function params below to only use push.Result
 	case spotTickerChannel:
-		return g.processTicker(push.Result, push.Time.Time())
+		return g.processTicker(push.Result, push.TimeMs.Time())
 	case spotTradesChannel:
 		return g.processTrades(push.Result)
 	case spotCandlesticksChannel:
--- a/exchanges/gateio/gateio_websocket_delivery_futures.go
+++ b/exchanges/gateio/gateio_websocket_delivery_futures.go
@@ -13,7 +13,6 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/exchanges/account"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/request"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/stream"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/subscription"
 )
@@ -55,7 +54,7 @@ func (g *Gateio) WsDeliveryFuturesConnect(ctx context.Context, conn stream.Conne
 	if err != nil {
 		return err
 	}
-	conn.SetupPingHandler(request.Unset, stream.PingHandler{
+	conn.SetupPingHandler(websocketRateLimitNotNeededEPL, stream.PingHandler{
 		Websocket:   true,
 		Delay:       time.Second * 5,
 		MessageType: websocket.PingMessage,
--- a/exchanges/gateio/gateio_websocket_futures.go
+++ b/exchanges/gateio/gateio_websocket_futures.go
@@ -19,7 +19,6 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/orderbook"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/request"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/stream"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/subscription"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/ticker"
@@ -76,7 +75,7 @@ func (g *Gateio) WsFuturesConnect(ctx context.Context, conn stream.Connection) e
 	if err != nil {
 		return err
 	}
-	conn.SetupPingHandler(request.Unset, stream.PingHandler{
+	conn.SetupPingHandler(websocketRateLimitNotNeededEPL, stream.PingHandler{
 		Websocket:   true,
 		MessageType: websocket.PingMessage,
 		Delay:       time.Second * 15,
--- a/exchanges/gateio/gateio_websocket_option.go
+++ b/exchanges/gateio/gateio_websocket_option.go
@@ -18,7 +18,6 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/orderbook"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/request"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/stream"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/subscription"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/ticker"
@@ -85,7 +84,7 @@ func (g *Gateio) WsOptionsConnect(ctx context.Context, conn stream.Connection) e
 	if err != nil {
 		return err
 	}
-	conn.SetupPingHandler(request.Unset, stream.PingHandler{
+	conn.SetupPingHandler(websocketRateLimitNotNeededEPL, stream.PingHandler{
 		Websocket:   true,
 		Delay:       time.Second * 5,
 		MessageType: websocket.PingMessage,
--- a/exchanges/gateio/gateio_websocket_request_spot.go
+++ b/exchanges/gateio/gateio_websocket_request_spot.go
@@ -0,0 +1,224 @@
+package gateio
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/thrasher-corp/gocryptotrader/common"
+	"github.com/thrasher-corp/gocryptotrader/currency"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/request"
+)
+
+var (
+	errOrdersEmpty      = errors.New("orders cannot be empty")
+	errNoOrdersToCancel = errors.New("no orders to cancel")
+	errChannelEmpty     = errors.New("channel cannot be empty")
+)
+
+// WebsocketSpotSubmitOrder submits an order via the websocket connection
+func (g *Gateio) WebsocketSpotSubmitOrder(ctx context.Context, order *WebsocketOrder) ([]WebsocketOrderResponse, error) {
+	return g.WebsocketSpotSubmitOrders(ctx, []WebsocketOrder{*order})
+}
+
+// WebsocketSpotSubmitOrders submits orders via the websocket connection. You can
+// send multiple orders in a single request. But only for one asset route.
+func (g *Gateio) WebsocketSpotSubmitOrders(ctx context.Context, orders []WebsocketOrder) ([]WebsocketOrderResponse, error) {
+	if len(orders) == 0 {
+		return nil, errOrdersEmpty
+	}
+
+	for i := range orders {
+		if orders[i].Text == "" {
+			// API requires Text field, or it will be rejected
+			orders[i].Text = "t-" + strconv.FormatInt(g.Counter.IncrementAndGet(), 10)
+		}
+		if orders[i].CurrencyPair == "" {
+			return nil, currency.ErrCurrencyPairEmpty
+		}
+		if orders[i].Side == "" {
+			return nil, order.ErrSideIsInvalid
+		}
+		if orders[i].Amount == "" {
+			return nil, errInvalidAmount
+		}
+		if orders[i].Type == "limit" && orders[i].Price == "" {
+			return nil, errInvalidPrice
+		}
+	}
+
+	if len(orders) == 1 {
+		var singleResponse WebsocketOrderResponse
+		return []WebsocketOrderResponse{singleResponse}, g.SendWebsocketRequest(ctx, spotPlaceOrderEPL, "spot.order_place", asset.Spot, orders[0], &singleResponse, 2)
+	}
+	var resp []WebsocketOrderResponse
+	return resp, g.SendWebsocketRequest(ctx, spotBatchOrdersEPL, "spot.order_place", asset.Spot, orders, &resp, 2)
+}
+
+// WebsocketSpotCancelOrder cancels an order via the websocket connection
+func (g *Gateio) WebsocketSpotCancelOrder(ctx context.Context, orderID string, pair currency.Pair, account string) (*WebsocketOrderResponse, error) {
+	if orderID == "" {
+		return nil, order.ErrOrderIDNotSet
+	}
+	if pair.IsEmpty() {
+		return nil, currency.ErrCurrencyPairEmpty
+	}
+
+	params := &WebsocketOrderRequest{OrderID: orderID, Pair: pair.String(), Account: account}
+
+	var resp WebsocketOrderResponse
+	return &resp, g.SendWebsocketRequest(ctx, spotCancelSingleOrderEPL, "spot.order_cancel", asset.Spot, params, &resp, 1)
+}
+
+// WebsocketSpotCancelAllOrdersByIDs cancels multiple orders via the websocket
+func (g *Gateio) WebsocketSpotCancelAllOrdersByIDs(ctx context.Context, o []WebsocketOrderBatchRequest) ([]WebsocketCancellAllResponse, error) {
+	if len(o) == 0 {
+		return nil, errNoOrdersToCancel
+	}
+
+	for i := range o {
+		if o[i].OrderID == "" {
+			return nil, order.ErrOrderIDNotSet
+		}
+		if o[i].Pair.IsEmpty() {
+			return nil, currency.ErrCurrencyPairEmpty
+		}
+	}
+
+	var resp []WebsocketCancellAllResponse
+	return resp, g.SendWebsocketRequest(ctx, spotCancelBatchOrdersEPL, "spot.order_cancel_ids", asset.Spot, o, &resp, 2)
+}
+
+// WebsocketSpotCancelAllOrdersByPair cancels all orders for a specific pair
+func (g *Gateio) WebsocketSpotCancelAllOrdersByPair(ctx context.Context, pair currency.Pair, side order.Side, account string) ([]WebsocketOrderResponse, error) {
+	if !pair.IsEmpty() && side == order.UnknownSide {
+		// This case will cancel all orders for every pair, this can be introduced later
+		return nil, fmt.Errorf("'%v' %w while pair is set", side, order.ErrSideIsInvalid)
+	}
+
+	sideStr := ""
+	if side != order.UnknownSide {
+		sideStr = side.Lower()
+	}
+
+	params := &WebsocketCancelParam{
+		Pair:    pair,
+		Side:    sideStr,
+		Account: account,
+	}
+
+	var resp []WebsocketOrderResponse
+	return resp, g.SendWebsocketRequest(ctx, spotCancelAllOpenOrdersEPL, "spot.order_cancel_cp", asset.Spot, params, &resp, 1)
+}
+
+// WebsocketSpotAmendOrder amends an order via the websocket connection
+func (g *Gateio) WebsocketSpotAmendOrder(ctx context.Context, amend *WebsocketAmendOrder) (*WebsocketOrderResponse, error) {
+	if amend == nil {
+		return nil, fmt.Errorf("%w: %T", common.ErrNilPointer, amend)
+	}
+
+	if amend.OrderID == "" {
+		return nil, order.ErrOrderIDNotSet
+	}
+
+	if amend.Pair.IsEmpty() {
+		return nil, currency.ErrCurrencyPairEmpty
+	}
+
+	if amend.Amount == "" && amend.Price == "" {
+		return nil, fmt.Errorf("%w: amount or price must be set", errInvalidAmount)
+	}
+
+	var resp WebsocketOrderResponse
+	return &resp, g.SendWebsocketRequest(ctx, spotAmendOrderEPL, "spot.order_amend", asset.Spot, amend, &resp, 1)
+}
+
+// WebsocketSpotGetOrderStatus gets the status of an order via the websocket connection
+func (g *Gateio) WebsocketSpotGetOrderStatus(ctx context.Context, orderID string, pair currency.Pair, account string) (*WebsocketOrderResponse, error) {
+	if orderID == "" {
+		return nil, order.ErrOrderIDNotSet
+	}
+	if pair.IsEmpty() {
+		return nil, currency.ErrCurrencyPairEmpty
+	}
+
+	params := &WebsocketOrderRequest{OrderID: orderID, Pair: pair.String(), Account: account}
+
+	var resp WebsocketOrderResponse
+	return &resp, g.SendWebsocketRequest(ctx, spotGetOrdersEPL, "spot.order_status", asset.Spot, params, &resp, 1)
+}
+
+// funnelResult is used to unmarshal the result of a websocket request back to the required caller type
+type funnelResult struct {
+	Result any `json:"result"`
+}
+
+// SendWebsocketRequest sends a websocket request to the exchange
+func (g *Gateio) SendWebsocketRequest(ctx context.Context, epl request.EndpointLimit, channel string, connSignature, params, result any, expectedResponses int) error {
+	paramPayload, err := json.Marshal(params)
+	if err != nil {
+		return err
+	}
+
+	conn, err := g.Websocket.GetConnection(connSignature)
+	if err != nil {
+		return err
+	}
+
+	tn := time.Now().Unix()
+	req := &WebsocketRequest{
+		Time:    tn,
+		Channel: channel,
+		Event:   "api",
+		Payload: WebsocketPayload{
+			// This request ID associated with the payload is the match to the
+			// response.
+			RequestID:    strconv.FormatInt(conn.GenerateMessageID(false), 10),
+			RequestParam: paramPayload,
+			Timestamp:    strconv.FormatInt(tn, 10),
+		},
+	}
+
+	responses, err := conn.SendMessageReturnResponsesWithInspector(ctx, epl, req.Payload.RequestID, req, expectedResponses, wsRespAckInspector{})
+	if err != nil {
+		return err
+	}
+
+	if len(responses) == 0 {
+		return common.ErrNoResponse
+	}
+
+	var inbound WebsocketAPIResponse
+	// The last response is the one we want to unmarshal, the other is just
+	// an ack. If the request fails on the ACK then we can unmarshal the error
+	// from that as the next response won't come anyway.
+	endResponse := responses[len(responses)-1]
+
+	if err := json.Unmarshal(endResponse, &inbound); err != nil {
+		return err
+	}
+
+	if inbound.Header.Status != "200" {
+		var wsErr WebsocketErrors
+		if err := json.Unmarshal(inbound.Data, &wsErr); err != nil {
+			return err
+		}
+		return fmt.Errorf("%s: %s", wsErr.Errors.Label, wsErr.Errors.Message)
+	}
+
+	return json.Unmarshal(inbound.Data, &funnelResult{Result: result})
+}
+
+type wsRespAckInspector struct{}
+
+// IsFinal checks the payload for an ack, it returns true if the payload does not contain an ack.
+// This will force the cancellation of further waiting for responses.
+func (wsRespAckInspector) IsFinal(data []byte) bool {
+	return !strings.Contains(string(data), "ack")
+}
--- a/exchanges/gateio/gateio_websocket_request_spot_test.go
+++ b/exchanges/gateio/gateio_websocket_request_spot_test.go
@@ -0,0 +1,248 @@
+package gateio
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/thrasher-corp/gocryptotrader/common"
+	"github.com/thrasher-corp/gocryptotrader/config"
+	"github.com/thrasher-corp/gocryptotrader/currency"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/stream"
+	testexch "github.com/thrasher-corp/gocryptotrader/internal/testing/exchange"
+)
+
+func TestWebsocketLogin(t *testing.T) {
+	t.Parallel()
+	err := g.websocketLogin(context.Background(), nil, "")
+	require.ErrorIs(t, err, common.ErrNilPointer)
+
+	err = g.websocketLogin(context.Background(), &stream.WebsocketConnection{}, "")
+	require.ErrorIs(t, err, errChannelEmpty)
+
+	sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
+
+	testexch.UpdatePairsOnce(t, g)
+	g := getWebsocketInstance(t, g) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes
+
+	demonstrationConn, err := g.Websocket.GetConnection(asset.Spot)
+	require.NoError(t, err)
+
+	err = g.websocketLogin(context.Background(), demonstrationConn, "spot.login")
+	require.NoError(t, err)
+}
+
+func TestWebsocketSpotSubmitOrder(t *testing.T) {
+	t.Parallel()
+	_, err := g.WebsocketSpotSubmitOrder(context.Background(), &WebsocketOrder{})
+	require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
+	out := &WebsocketOrder{CurrencyPair: "BTC_USDT"}
+	_, err = g.WebsocketSpotSubmitOrder(context.Background(), out)
+	require.ErrorIs(t, err, order.ErrSideIsInvalid)
+	out.Side = strings.ToLower(order.Buy.String())
+	_, err = g.WebsocketSpotSubmitOrder(context.Background(), out)
+	require.ErrorIs(t, err, errInvalidAmount)
+	out.Amount = "0.0003"
+	out.Type = "limit"
+	_, err = g.WebsocketSpotSubmitOrder(context.Background(), out)
+	require.ErrorIs(t, err, errInvalidPrice)
+	out.Price = "20000"
+
+	sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
+
+	testexch.UpdatePairsOnce(t, g)
+	g := getWebsocketInstance(t, g) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes
+
+	got, err := g.WebsocketSpotSubmitOrder(context.Background(), out)
+	require.NoError(t, err)
+	require.NotEmpty(t, got)
+}
+
+func TestWebsocketSpotSubmitOrders(t *testing.T) {
+	t.Parallel()
+	_, err := g.WebsocketSpotSubmitOrders(context.Background(), nil)
+	require.ErrorIs(t, err, errOrdersEmpty)
+	_, err = g.WebsocketSpotSubmitOrders(context.Background(), make([]WebsocketOrder, 1))
+	require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
+	out := WebsocketOrder{CurrencyPair: "BTC_USDT"}
+	_, err = g.WebsocketSpotSubmitOrders(context.Background(), []WebsocketOrder{out})
+	require.ErrorIs(t, err, order.ErrSideIsInvalid)
+	out.Side = strings.ToLower(order.Buy.String())
+	_, err = g.WebsocketSpotSubmitOrders(context.Background(), []WebsocketOrder{out})
+	require.ErrorIs(t, err, errInvalidAmount)
+	out.Amount = "0.0003"
+	out.Type = "limit"
+	_, err = g.WebsocketSpotSubmitOrders(context.Background(), []WebsocketOrder{out})
+	require.ErrorIs(t, err, errInvalidPrice)
+	out.Price = "20000"
+
+	sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
+
+	testexch.UpdatePairsOnce(t, g)
+	g := getWebsocketInstance(t, g) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes
+
+	// test single order
+	got, err := g.WebsocketSpotSubmitOrders(context.Background(), []WebsocketOrder{out})
+	require.NoError(t, err)
+	require.NotEmpty(t, got)
+
+	// test batch orders
+	got, err = g.WebsocketSpotSubmitOrders(context.Background(), []WebsocketOrder{out, out})
+	require.NoError(t, err)
+	require.NotEmpty(t, got)
+}
+
+func TestWebsocketSpotCancelOrder(t *testing.T) {
+	t.Parallel()
+	_, err := g.WebsocketSpotCancelOrder(context.Background(), "", currency.EMPTYPAIR, "")
+	require.ErrorIs(t, err, order.ErrOrderIDNotSet)
+	_, err = g.WebsocketSpotCancelOrder(context.Background(), "1337", currency.EMPTYPAIR, "")
+	require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
+
+	btcusdt, err := currency.NewPairFromString("BTC_USDT")
+	require.NoError(t, err)
+
+	sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
+
+	testexch.UpdatePairsOnce(t, g)
+	g := getWebsocketInstance(t, g) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes
+
+	got, err := g.WebsocketSpotCancelOrder(context.Background(), "644913098758", btcusdt, "")
+	require.NoError(t, err)
+	require.NotEmpty(t, got)
+}
+
+func TestWebsocketSpotCancelAllOrdersByIDs(t *testing.T) {
+	t.Parallel()
+	_, err := g.WebsocketSpotCancelAllOrdersByIDs(context.Background(), []WebsocketOrderBatchRequest{})
+	require.ErrorIs(t, err, errNoOrdersToCancel)
+	out := WebsocketOrderBatchRequest{}
+	_, err = g.WebsocketSpotCancelAllOrdersByIDs(context.Background(), []WebsocketOrderBatchRequest{out})
+	require.ErrorIs(t, err, order.ErrOrderIDNotSet)
+	out.OrderID = "1337"
+	_, err = g.WebsocketSpotCancelAllOrdersByIDs(context.Background(), []WebsocketOrderBatchRequest{out})
+	require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
+
+	out.Pair, err = currency.NewPairFromString("BTC_USDT")
+	require.NoError(t, err)
+
+	sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
+
+	testexch.UpdatePairsOnce(t, g)
+	g := getWebsocketInstance(t, g) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes
+
+	out.OrderID = "644913101755"
+	got, err := g.WebsocketSpotCancelAllOrdersByIDs(context.Background(), []WebsocketOrderBatchRequest{out})
+	require.NoError(t, err)
+	require.NotEmpty(t, got)
+}
+
+func TestWebsocketSpotCancelAllOrdersByPair(t *testing.T) {
+	t.Parallel()
+	pair, err := currency.NewPairFromString("LTC_USDT")
+	require.NoError(t, err)
+
+	_, err = g.WebsocketSpotCancelAllOrdersByPair(context.Background(), pair, 0, "")
+	require.ErrorIs(t, err, order.ErrSideIsInvalid)
+
+	sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
+
+	testexch.UpdatePairsOnce(t, g)
+	g := getWebsocketInstance(t, g) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes
+
+	got, err := g.WebsocketSpotCancelAllOrdersByPair(context.Background(), currency.EMPTYPAIR, order.Buy, "")
+	require.NoError(t, err)
+	require.NotEmpty(t, got)
+}
+
+func TestWebsocketSpotAmendOrder(t *testing.T) {
+	t.Parallel()
+
+	_, err := g.WebsocketSpotAmendOrder(context.Background(), nil)
+	require.ErrorIs(t, err, common.ErrNilPointer)
+
+	amend := &WebsocketAmendOrder{}
+	_, err = g.WebsocketSpotAmendOrder(context.Background(), amend)
+	require.ErrorIs(t, err, order.ErrOrderIDNotSet)
+
+	amend.OrderID = "1337"
+	_, err = g.WebsocketSpotAmendOrder(context.Background(), amend)
+	require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
+
+	amend.Pair, err = currency.NewPairFromString("BTC_USDT")
+	require.NoError(t, err)
+
+	_, err = g.WebsocketSpotAmendOrder(context.Background(), amend)
+	require.ErrorIs(t, err, errInvalidAmount)
+
+	amend.Amount = "0.0004"
+
+	sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
+
+	testexch.UpdatePairsOnce(t, g)
+	g := getWebsocketInstance(t, g) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes
+
+	amend.OrderID = "645029162673"
+	got, err := g.WebsocketSpotAmendOrder(context.Background(), amend)
+	require.NoError(t, err)
+	require.NotEmpty(t, got)
+}
+
+func TestWebsocketSpotGetOrderStatus(t *testing.T) {
+	t.Parallel()
+
+	_, err := g.WebsocketSpotGetOrderStatus(context.Background(), "", currency.EMPTYPAIR, "")
+	require.ErrorIs(t, err, order.ErrOrderIDNotSet)
+
+	_, err = g.WebsocketSpotGetOrderStatus(context.Background(), "1337", currency.EMPTYPAIR, "")
+	require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
+
+	sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
+
+	testexch.UpdatePairsOnce(t, g)
+	g := getWebsocketInstance(t, g) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes
+
+	pair, err := currency.NewPairFromString("BTC_USDT")
+	require.NoError(t, err)
+
+	got, err := g.WebsocketSpotGetOrderStatus(context.Background(), "644999650452", pair, "")
+	require.NoError(t, err)
+	require.NotEmpty(t, got)
+}
+
+// getWebsocketInstance returns a websocket instance copy for testing.
+// This restricts the pairs to a single pair per asset type to reduce test time.
+func getWebsocketInstance(t *testing.T, g *Gateio) *Gateio {
+	t.Helper()
+
+	cpy := new(Gateio)
+	cpy.SetDefaults()
+	gConf, err := config.GetConfig().GetExchangeConfig("GateIO")
+	require.NoError(t, err)
+	gConf.API.AuthenticatedSupport = true
+	gConf.API.AuthenticatedWebsocketSupport = true
+	gConf.API.Credentials.Key = apiKey
+	gConf.API.Credentials.Secret = apiSecret
+
+	require.NoError(t, cpy.Setup(gConf), "Test instance Setup must not error")
+	cpy.CurrencyPairs.Load(&g.CurrencyPairs)
+
+	for _, a := range cpy.GetAssetTypes(true) {
+		if a != asset.Spot {
+			require.NoError(t, cpy.CurrencyPairs.SetAssetEnabled(a, false))
+			continue
+		}
+		avail, err := cpy.GetAvailablePairs(a)
+		require.NoError(t, err)
+		if len(avail) > 1 {
+			avail = avail[:1]
+		}
+		require.NoError(t, cpy.SetPairs(avail, a, true))
+	}
+	require.NoError(t, cpy.Websocket.Connect())
+	return cpy
+}
--- a/exchanges/gateio/gateio_websocket_request_types.go
+++ b/exchanges/gateio/gateio_websocket_request_types.go
@@ -0,0 +1,143 @@
+package gateio
+
+import (
+	"encoding/json"
+
+	"github.com/thrasher-corp/gocryptotrader/currency"
+	"github.com/thrasher-corp/gocryptotrader/types"
+)
+
+// WebsocketAPIResponse defines a general websocket response for api calls
+type WebsocketAPIResponse struct {
+	Header Header          `json:"header"`
+	Data   json.RawMessage `json:"data"`
+}
+
+// Header defines a websocket header
+type Header struct {
+	ResponseTime types.Time `json:"response_time"`
+	Status       string     `json:"status"`
+	Channel      string     `json:"channel"`
+	Event        string     `json:"event"`
+	ClientID     string     `json:"client_id"`
+	ConnectionID string     `json:"conn_id"`
+	TraceID      string     `json:"trace_id"`
+}
+
+// WebsocketRequest defines a websocket request
+type WebsocketRequest struct {
+	Time    int64            `json:"time,omitempty"`
+	ID      int64            `json:"id,omitempty"`
+	Channel string           `json:"channel"`
+	Event   string           `json:"event"`
+	Payload WebsocketPayload `json:"payload"`
+}
+
+// WebsocketPayload defines an individualised websocket payload
+type WebsocketPayload struct {
+	RequestID string `json:"req_id,omitempty"`
+	// APIKey and signature are only required in the initial login request
+	// which is done when the connection is established.
+	APIKey       string          `json:"api_key,omitempty"`
+	Timestamp    string          `json:"timestamp,omitempty"`
+	Signature    string          `json:"signature,omitempty"`
+	RequestParam json.RawMessage `json:"req_param,omitempty"`
+}
+
+// WebsocketErrors defines a websocket error
+type WebsocketErrors struct {
+	Errors struct {
+		Label   string `json:"label"`
+		Message string `json:"message"`
+	} `json:"errs"`
+}
+
+// WebsocketOrder defines a websocket order
+type WebsocketOrder struct {
+	Text         string `json:"text"`
+	CurrencyPair string `json:"currency_pair,omitempty"`
+	Type         string `json:"type,omitempty"`
+	Account      string `json:"account,omitempty"`
+	Side         string `json:"side,omitempty"`
+	Amount       string `json:"amount,omitempty"`
+	Price        string `json:"price,omitempty"`
+	TimeInForce  string `json:"time_in_force,omitempty"`
+	Iceberg      string `json:"iceberg,omitempty"`
+	AutoBorrow   bool   `json:"auto_borrow,omitempty"`
+	AutoRepay    bool   `json:"auto_repay,omitempty"`
+	StpAct       string `json:"stp_act,omitempty"`
+}
+
+// WebsocketOrderResponse defines a websocket order response
+type WebsocketOrderResponse struct {
+	Left               types.Number  `json:"left"`
+	UpdateTime         types.Time    `json:"update_time"`
+	Amount             types.Number  `json:"amount"`
+	CreateTime         types.Time    `json:"create_time"`
+	Price              types.Number  `json:"price"`
+	FinishAs           string        `json:"finish_as"`
+	TimeInForce        string        `json:"time_in_force"`
+	CurrencyPair       currency.Pair `json:"currency_pair"`
+	Type               string        `json:"type"`
+	Account            string        `json:"account"`
+	Side               string        `json:"side"`
+	AmendText          string        `json:"amend_text"`
+	Text               string        `json:"text"`
+	Status             string        `json:"status"`
+	Iceberg            types.Number  `json:"iceberg"`
+	FilledTotal        types.Number  `json:"filled_total"`
+	ID                 string        `json:"id"`
+	FillPrice          types.Number  `json:"fill_price"`
+	UpdateTimeMs       types.Time    `json:"update_time_ms"`
+	CreateTimeMs       types.Time    `json:"create_time_ms"`
+	Fee                types.Number  `json:"fee"`
+	FeeCurrency        currency.Code `json:"fee_currency"`
+	PointFee           types.Number  `json:"point_fee"`
+	GTFee              types.Number  `json:"gt_fee"`
+	GTMakerFee         types.Number  `json:"gt_maker_fee"`
+	GTTakerFee         types.Number  `json:"gt_taker_fee"`
+	GTDiscount         bool          `json:"gt_discount"`
+	RebatedFee         types.Number  `json:"rebated_fee"`
+	RebatedFeeCurrency currency.Code `json:"rebated_fee_currency"`
+	STPID              int           `json:"stp_id"`
+	STPAct             string        `json:"stp_act"`
+}
+
+// WebsocketOrderBatchRequest defines a websocket order batch request
+type WebsocketOrderBatchRequest struct {
+	OrderID string        `json:"id"` // This require id tag not order_id
+	Pair    currency.Pair `json:"currency_pair"`
+	Account string        `json:"account,omitempty"`
+}
+
+// WebsocketOrderRequest defines a websocket order request
+type WebsocketOrderRequest struct {
+	OrderID string `json:"order_id"` // This requires order_id tag
+	Pair    string `json:"pair"`
+	Account string `json:"account,omitempty"`
+}
+
+// WebsocketCancellAllResponse defines a websocket order cancel response
+type WebsocketCancellAllResponse struct {
+	Pair      currency.Pair `json:"currency_pair"`
+	Label     string        `json:"label"`
+	Message   string        `json:"message"`
+	Succeeded bool          `json:"succeeded"`
+}
+
+// WebsocketCancelParam is a struct to hold the parameters for cancelling orders
+type WebsocketCancelParam struct {
+	Pair    currency.Pair `json:"pair"`
+	Side    string        `json:"side"`
+	Account string        `json:"account,omitempty"`
+}
+
+// WebsocketAmendOrder defines a websocket amend order
+type WebsocketAmendOrder struct {
+	OrderID   string        `json:"order_id"`
+	Pair      currency.Pair `json:"currency_pair"`
+	Account   string        `json:"account,omitempty"`
+	AmendText string        `json:"amend_text,omitempty"`
+	Price     string        `json:"price,omitempty"`
+	Amount    string        `json:"amount,omitempty"`
+}
--- a/exchanges/gateio/gateio_wrapper.go
+++ b/exchanges/gateio/gateio_wrapper.go
@@ -218,6 +218,8 @@ func (g *Gateio) Setup(exch *config.Exchange) error {
 		Unsubscriber:             g.Unsubscribe,
 		GenerateSubscriptions:    g.generateSubscriptionsSpot,
 		Connector:                g.WsConnectSpot,
+		Authenticate:             g.authenticateSpot,
+		MessageFilter:            asset.Spot,
 		BespokeGenerateMessageID: g.GenerateWebsocketMessageID,
 	})
 	if err != nil {
@@ -235,6 +237,7 @@ func (g *Gateio) Setup(exch *config.Exchange) error {
 		Unsubscriber:             g.FuturesUnsubscribe,
 		GenerateSubscriptions:    func() (subscription.List, error) { return g.GenerateFuturesDefaultSubscriptions(currency.USDT) },
 		Connector:                g.WsFuturesConnect,
+		MessageFilter:            asset.USDTMarginedFutures,
 		BespokeGenerateMessageID: g.GenerateWebsocketMessageID,
 	})
 	if err != nil {
@@ -253,6 +256,7 @@ func (g *Gateio) Setup(exch *config.Exchange) error {
 		Unsubscriber:             g.FuturesUnsubscribe,
 		GenerateSubscriptions:    func() (subscription.List, error) { return g.GenerateFuturesDefaultSubscriptions(currency.BTC) },
 		Connector:                g.WsFuturesConnect,
+		MessageFilter:            asset.CoinMarginedFutures,
 		BespokeGenerateMessageID: g.GenerateWebsocketMessageID,
 	})
 	if err != nil {
@@ -272,6 +276,7 @@ func (g *Gateio) Setup(exch *config.Exchange) error {
 		Unsubscriber:             g.DeliveryFuturesUnsubscribe,
 		GenerateSubscriptions:    g.GenerateDeliveryFuturesDefaultSubscriptions,
 		Connector:                g.WsDeliveryFuturesConnect,
+		MessageFilter:            asset.DeliveryFutures,
 		BespokeGenerateMessageID: g.GenerateWebsocketMessageID,
 	})
 	if err != nil {
@@ -288,6 +293,7 @@ func (g *Gateio) Setup(exch *config.Exchange) error {
 		Unsubscriber:             g.OptionsUnsubscribe,
 		GenerateSubscriptions:    g.GenerateOptionsDefaultSubscriptions,
 		Connector:                g.WsOptionsConnect,
+		MessageFilter:            asset.Options,
 		BespokeGenerateMessageID: g.GenerateWebsocketMessageID,
 	})
 }