support global order quantity convert to okx contract size

Author: anywhy

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
 	}
@@ -329,7 +331,10 @@ func (e *Exchange) SubmitOrder(ctx context.Context, order types.SubmitOrder) (*t
 			orderReq.TradeMode(okexapi.TradeModeCross)
 		}
 	} else if e.IsFutures {
+		quantity := order.Market.AdjustQuantityToContractSize(order.Quantity)
+		orderReq.Size(order.Market.FormatQuantity(quantity))
 		orderReq.InstrumentID(toLocalSymbol(order.Symbol, okexapi.InstrumentTypeSwap))
+
 		if e.FuturesSettings.IsIsolatedFutures {
 			orderReq.TradeMode(okexapi.TradeModeIsolated)
 		} else {

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"`

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,17 @@ 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 {
+	// Validate input parameters
+	if quantity.Sign() <= 0 || m.ContractValue.Sign() <= 0 || m.StepSize.Sign() <= 0 {
+		return fixedpoint.Zero
+	}
+
+	contractQuantity := quantity.Div(m.ContractValue)
+	return m.RoundUpByStepSize(contractQuantity)
+}
+
 type MarketMap map[string]Market
 
 func (m MarketMap) Add(market Market) {

pkg/types/market_test.go

@@ -266,3 +266,61 @@ 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:     "negative quantity",
+			quantity: fixedpoint.NewFromFloat(-0.01),
+			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())
+		})
+	}
+}