Merge pull request #2025 from anywhy/okx-contract-size

c9s · web-flow · commit da12d3129d8c · 2025-05-16T19:43:58.000+08:00
FEATURE: [okx]  support global order quantity convert to okx contract size
diff --git a/pkg/exchange/okex/exchange.go b/pkg/exchange/okex/exchange.go
@@ -170,6 +170,8 @@ func (e *Exchange) QueryMarkets(ctx context.Context) (types.MarketMap, error) {
 			// OKEx does not offer minimal notional, use 1 USD here.
 			MinNotional: fixedpoint.One,
 			MinAmount:   fixedpoint.One,
+
+			ContractValue: instrument.ContractValue,
 		}
 		markets[symbol] = market
 	}
@@ -184,10 +186,7 @@ func (e *Exchange) QueryTicker(ctx context.Context, symbol string) (*types.Ticke
 		return nil, fmt.Errorf("ticker rate limiter wait error: %w", err)
 	}
 
-	symbol = toLocalSymbol(symbol)
-	if e.IsFutures {
-		symbol = toLocalSymbol(symbol, okexapi.InstrumentTypeSwap)
-	}
+	symbol = e.getInstrumentId(symbol)
 	marketTicker, err := e.client.NewGetTickerRequest().InstId(symbol).Do(ctx)
 	if err != nil {
 		return nil, err
@@ -314,7 +313,7 @@ func (e *Exchange) queryAccountBalance(ctx context.Context) ([]okexapi.Account,
 func (e *Exchange) SubmitOrder(ctx context.Context, order types.SubmitOrder) (*types.Order, error) {
 	orderReq := e.client.NewPlaceOrderRequest()
 
-	orderReq.InstrumentID(toLocalSymbol(order.Symbol))
+	orderReq.InstrumentID(e.getInstrumentId(order.Symbol))
 	orderReq.Side(toLocalSideType(order.Side))
 	orderReq.Size(order.Market.FormatQuantity(order.Quantity))
 
@@ -329,7 +328,6 @@ func (e *Exchange) SubmitOrder(ctx context.Context, order types.SubmitOrder) (*t
 			orderReq.TradeMode(okexapi.TradeModeCross)
 		}
 	} else if e.IsFutures {
-		orderReq.InstrumentID(toLocalSymbol(order.Symbol, okexapi.InstrumentTypeSwap))
 		if e.FuturesSettings.IsIsolatedFutures {
 			orderReq.TradeMode(okexapi.TradeModeIsolated)
 		} else {
@@ -350,12 +348,8 @@ func (e *Exchange) SubmitOrder(ctx context.Context, order types.SubmitOrder) (*t
 	case types.OrderTypeMarket:
 		// target currency = Default is quote_ccy for buy, base_ccy for sell
 		// Because our order.Quantity unit is base coin, so we indicate the target currency to Base.
-		switch order.Side {
-		case types.SideTypeSell:
-			orderReq.Size(order.Market.FormatQuantity(order.Quantity))
-			orderReq.TargetCurrency(okexapi.TargetCurrencyBase)
-		case types.SideTypeBuy:
-			orderReq.Size(order.Market.FormatQuantity(order.Quantity))
+		// Only applicable to SPOT Market Orders
+		if !e.IsFutures {
 			orderReq.TargetCurrency(okexapi.TargetCurrencyBase)
 		}
 	}
@@ -419,7 +413,7 @@ func (e *Exchange) SubmitOrder(ctx context.Context, order types.SubmitOrder) (*t
 // QueryOpenOrders retrieves the pending orders. The data returned is ordered by createdTime, and we utilized the
 // `After` parameter to acquire all orders.
 func (e *Exchange) QueryOpenOrders(ctx context.Context, symbol string) (orders []types.Order, err error) {
-	instrumentID := toLocalSymbol(symbol)
+	instrumentID := e.getInstrumentId(symbol)
 
 	nextCursor := int64(0)
 	for {
@@ -434,7 +428,6 @@ func (e *Exchange) QueryOpenOrders(ctx context.Context, symbol string) (orders [
 		if e.MarginSettings.IsMargin {
 			req.InstrumentType(okexapi.InstrumentTypeMargin)
 		} else if e.IsFutures {
-			req.InstrumentID(toLocalSymbol(symbol, okexapi.InstrumentTypeSwap))
 			req.InstrumentType(okexapi.InstrumentTypeSwap)
 		}
 
@@ -479,10 +472,8 @@ func (e *Exchange) CancelOrders(ctx context.Context, orders ...types.Order) erro
 		}
 
 		req := e.client.NewCancelOrderRequest()
-		req.InstrumentID(toLocalSymbol(order.Symbol))
-		if e.IsFutures {
-			req.InstrumentID(toLocalSymbol(order.Symbol, okexapi.InstrumentTypeSwap))
-		}
+		req.InstrumentID(e.getInstrumentId(order.Symbol))
+
 		req.OrderID(strconv.FormatUint(order.OrderID, 10))
 		if len(order.ClientOrderID) > 0 {
 			if ok := clientOrderIdRegex.MatchString(order.ClientOrderID); !ok {
@@ -520,10 +511,7 @@ func (e *Exchange) QueryKLines(
 		return nil, fmt.Errorf("failed to get interval: %w", err)
 	}
 
-	instrumentID := toLocalSymbol(symbol)
-	if e.IsFutures {
-		instrumentID = toLocalSymbol(symbol, okexapi.InstrumentTypeSwap)
-	}
+	instrumentID := e.getInstrumentId(symbol)
 
 	req := e.client.NewGetCandlesRequest().InstrumentID(instrumentID)
 	req.Bar(intervalParam)
@@ -558,10 +546,8 @@ func (e *Exchange) QueryOrder(ctx context.Context, q types.OrderQuery) (*types.O
 		return nil, errors.New("okex.QueryOrder: OrderId or ClientOrderId is required parameter")
 	}
 	req := e.client.NewGetOrderDetailsRequest()
-	instrumentID := toLocalSymbol(q.Symbol)
-	if e.IsFutures {
-		instrumentID = toLocalSymbol(q.Symbol, okexapi.InstrumentTypeSwap)
-	}
+	instrumentID := e.getInstrumentId(q.Symbol)
+
 	req.InstrumentID(instrumentID)
 	// Either ordId or clOrdId is required, if both are passed, ordId will be used
 	// ref: https://www.okx.com/docs-v5/en/#order-book-trading-trade-get-order-details
@@ -591,10 +577,7 @@ func (e *Exchange) QueryOrderTrades(ctx context.Context, q types.OrderQuery) (tr
 
 	req := e.client.NewGetThreeDaysTransactionHistoryRequest()
 	if len(q.Symbol) != 0 {
-		instrumentID := toLocalSymbol(q.Symbol)
-		if e.IsFutures {
-			instrumentID = toLocalSymbol(q.Symbol, okexapi.InstrumentTypeSwap)
-		}
+		instrumentID := e.getInstrumentId(q.Symbol)
 		req.InstrumentID(instrumentID)
 	}
 
@@ -654,11 +637,7 @@ func (e *Exchange) QueryClosedOrders(
 	}
 
 	req := e.client.NewGetOrderHistoryRequest()
-	instrumentID := toLocalSymbol(symbol)
-	if e.IsFutures {
-		instrumentID = toLocalSymbol(symbol, okexapi.InstrumentTypeSwap)
-		req.InstrumentType(okexapi.InstrumentTypeSwap)
-	}
+	instrumentID := e.getInstrumentId(symbol)
 
 	req.InstrumentID(instrumentID).
 		StartTime(since).
@@ -814,6 +793,14 @@ func (e *Exchange) getInstrumentType() okexapi.InstrumentType {
 	return okexapi.InstrumentTypeSpot
 }
 
+func (e *Exchange) getInstrumentId(symbol string) string {
+	if e.IsFutures {
+		return toLocalSymbol(symbol, okexapi.InstrumentTypeSwap)
+	}
+
+	return toLocalSymbol(symbol)
+}
+
 func (e *Exchange) QueryDepositHistory(
 	ctx context.Context, asset string, startTime, endTime *time.Time,
 ) ([]types.Deposit, error) {
@@ -904,11 +891,7 @@ func (e *Exchange) QueryTrades(
 		"req_id":        uuid.New().String(),
 	})
 
-	instrumentID := toLocalSymbol(symbol)
-	if e.IsFutures {
-		instrumentID = toLocalSymbol(symbol, okexapi.InstrumentTypeSwap)
-	}
-
+	instrumentID := e.getInstrumentId(symbol)
 	instrType := e.getInstrumentType()
 
 	if lessThan3Day {
diff --git a/pkg/exchange/okex/exchange_test.go b/pkg/exchange/okex/exchange_test.go
@@ -500,6 +500,56 @@ func TestExchange_Futures_SubmitOrder(t *testing.T) {
 	assert.NotEmpty(t, orders)
 }
 
+func TestExchange_Futures_SubmitMarketOrder(t *testing.T) {
+	key, secret, passphrase, ok := testutil.IntegrationTestWithPassphraseConfigured(t, "OKEX")
+	if !ok {
+		t.SkipNow()
+		return
+	}
+
+	ex := New(key, secret, passphrase)
+	ex.UseFutures()
+	dualSidePosition = true
+
+	markets, err := ex.QueryMarkets(context.Background())
+	assert.NoError(t, err)
+
+	market := markets["BTCUSDT"]
+	orders, err := ex.SubmitOrder(context.Background(), types.SubmitOrder{
+		Symbol:   "BTCUSDT",
+		Side:     types.SideTypeSell,
+		Type:     types.OrderTypeMarket,
+		Quantity: market.MinQuantity,
+		Market:   market,
+	})
+	assert.NoError(t, err)
+	assert.NotEmpty(t, orders)
+}
+
+func TestExchange_Spot_SubmitMarketOrder(t *testing.T) {
+	key, secret, passphrase, ok := testutil.IntegrationTestWithPassphraseConfigured(t, "OKEX")
+	if !ok {
+		t.SkipNow()
+		return
+	}
+
+	ex := New(key, secret, passphrase)
+
+	markets, err := ex.QueryMarkets(context.Background())
+	assert.NoError(t, err)
+
+	market := markets["BTCUSDT"]
+	orders, err := ex.SubmitOrder(context.Background(), types.SubmitOrder{
+		Symbol:   "BTCUSDT",
+		Side:     types.SideTypeBuy,
+		Type:     types.OrderTypeMarket,
+		Quantity: market.MinQuantity,
+		Market:   market,
+	})
+	assert.NoError(t, err)
+	assert.NotEmpty(t, orders)
+}
+
 func TestExchange_QueryKlines(t *testing.T) {
 	key, secret, passphrase, ok := testutil.IntegrationTestWithPassphraseConfigured(t, "OKEX")
 	if !ok {
@@ -758,3 +808,52 @@ func TestExchange_QueryPositionRisk(t *testing.T) {
 		}
 	})
 }
+
+func TestExchange_getInstrumentId(t *testing.T) {
+	tests := []struct {
+		name           string
+		symbol         string
+		isFutures      bool
+		expectedSymbol string
+	}{
+		{
+			name:           "BTCUSDT in spot mode",
+			symbol:         "BTCUSDT",
+			isFutures:      false,
+			expectedSymbol: "BTC-USDT",
+		},
+		{
+			name:           "BTCUSDT in futures mode",
+			symbol:         "BTCUSDT",
+			isFutures:      true,
+			expectedSymbol: "BTC-USDT-SWAP",
+		},
+		{
+			name:           "ETHUSDT in spot mode",
+			symbol:         "ETHUSDT",
+			isFutures:      false,
+			expectedSymbol: "ETH-USDT",
+		},
+		{
+			name:           "ETHUSDT in futures mode",
+			symbol:         "ETHUSDT",
+			isFutures:      true,
+			expectedSymbol: "ETH-USDT-SWAP",
+		},
+		{
+			name:           "empty symbol",
+			symbol:         "",
+			isFutures:      false,
+			expectedSymbol: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ex := New("", "", "")
+			ex.IsFutures = tt.isFutures
+			got := ex.getInstrumentId(tt.symbol)
+			assert.Equal(t, tt.expectedSymbol, got)
+		})
+	}
+}
diff --git a/pkg/exchange/okex/okexapi/get_instruments_info_request.go b/pkg/exchange/okex/okexapi/get_instruments_info_request.go
@@ -15,7 +15,7 @@ type InstrumentInfo struct {
 	BaseCurrency          string                     `json:"baseCcy"`
 	QuoteCurrency         string                     `json:"quoteCcy"`
 	SettleCurrency        string                     `json:"settleCcy"`
-	ContractValue         string                     `json:"ctVal"`
+	ContractValue         fixedpoint.Value           `json:"ctVal"`
 	ContractMultiplier    string                     `json:"ctMult"`
 	ContractValueCurrency string                     `json:"ctValCcy"`
 	ListTime              types.MillisecondTimestamp `json:"listTime"`
diff --git a/pkg/types/market.go b/pkg/types/market.go
@@ -55,6 +55,8 @@ type Market struct {
 
 	MinPrice fixedpoint.Value `json:"minPrice,omitempty"`
 	MaxPrice fixedpoint.Value `json:"maxPrice,omitempty"`
+
+	ContractValue fixedpoint.Value `json:"contractValue,omitempty"`
 }
 
 func (m Market) IsDustQuantity(quantity, price fixedpoint.Value) bool {
@@ -265,6 +267,16 @@ func (m Market) AdjustQuantityByMaxAmount(quantity, currentPrice, maxAmount fixe
 	return m.TruncateQuantity(quantity)
 }
 
+// AdjustQuantityToContractSize adjusts the quantity to contract size
+func (m Market) AdjustQuantityToContractSize(quantity fixedpoint.Value) fixedpoint.Value {
+	if m.ContractValue.Sign() <= 0 || m.StepSize.Sign() <= 0 {
+		return quantity
+	}
+
+	contractQuantity := quantity.Div(m.ContractValue)
+	return m.RoundUpByStepSize(contractQuantity)
+}
+
 type MarketMap map[string]Market
 
 func (m MarketMap) Add(markets ...Market) {
diff --git a/pkg/types/market_test.go b/pkg/types/market_test.go
@@ -266,3 +266,56 @@ func TestMarket_AdjustQuantityByMinNotional(t *testing.T) {
 		assert.False(t, market.IsDustQuantity(q2, testCase.price))
 	}
 }
+
+func TestMarket_AdjustQuantityToContractSize(t *testing.T) {
+	market := Market{
+		Symbol:          "BTCUSDT",
+		StepSize:        fixedpoint.NewFromFloat(0.01), // step size is 0.01 BTC
+		ContractValue:   fixedpoint.NewFromFloat(0.01), // 1 contract = 0.01 BTC
+		VolumePrecision: 8,
+	}
+
+	testCases := []struct {
+		name     string
+		quantity fixedpoint.Value
+		expect   fixedpoint.Value
+	}{
+		{
+			name:     "exact contract size",
+			quantity: fixedpoint.NewFromFloat(0.01), // 1 contract
+			expect:   fixedpoint.NewFromFloat(1.0),
+		},
+		{
+			name:     "multiple contracts",
+			quantity: fixedpoint.NewFromFloat(0.05), // 5 contracts
+			expect:   fixedpoint.NewFromFloat(5.0),
+		},
+		{
+			name:     "round up to step size",
+			quantity: fixedpoint.NewFromFloat(0.024), // 2.4 contracts
+			expect:   fixedpoint.NewFromFloat(2.4),
+		},
+		{
+			name:     "zero quantity",
+			quantity: fixedpoint.Zero,
+			expect:   fixedpoint.Zero,
+		},
+		{
+			name:     "small quantity",
+			quantity: fixedpoint.NewFromFloat(0.005), // 0.5 contracts
+			expect:   fixedpoint.NewFromFloat(0.5),
+		},
+		{
+			name:     "large quantity",
+			quantity: fixedpoint.NewFromFloat(1.0), // 100 contracts
+			expect:   fixedpoint.NewFromFloat(100.0),
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := market.AdjustQuantityToContractSize(tc.quantity)
+			assert.Equal(t, tc.expect, result, "quantity: %v", tc.quantity.Float64())
+		})
+	}
+}
