Merge pull request #2385 from c9s/c9s/xmaker/bal-based-quoting

FEATURE: [xmaker] integrate balance weight quoting

Author: c9s

pkg/strategy/xmaker/hedgemarket.go

@@ -103,6 +103,50 @@ func (c *HedgeMarketConfig) Defaults() error {
 	return nil
 }
 
+// ResolveQuotingDepthInQuote returns the quoting depth in quote currency.
+// Priority:
+//  1. If QuotingDepthInQuote is configured (> 0), return it directly.
+//  2. Else if QuotingDepth (base) is configured and latestPrice > 0, convert
+//     base depth to quote via base * latestPrice.
+//  3. Otherwise return zero.
+func (c *HedgeMarketConfig) ResolveQuotingDepthInQuote(latestPrice fixedpoint.Value) fixedpoint.Value {
+	if c == nil {
+		return fixedpoint.Zero
+	}
+
+	if c.QuotingDepthInQuote.Sign() > 0 {
+		return c.QuotingDepthInQuote
+	}
+
+	if c.QuotingDepth.Sign() > 0 && latestPrice.Sign() > 0 {
+		return c.QuotingDepth.Mul(latestPrice)
+	}
+
+	return fixedpoint.Zero
+}
+
+// ResolveQuotingDepthInBase returns the quoting depth in base currency.
+// Priority:
+//  1. If QuotingDepth (base) is configured (> 0), return it directly.
+//  2. Else if QuotingDepthInQuote is configured and latestPrice > 0, convert
+//     quote depth to base via quote / latestPrice.
+//  3. Otherwise return zero.
+func (c *HedgeMarketConfig) ResolveQuotingDepthInBase(latestPrice fixedpoint.Value) fixedpoint.Value {
+	if c == nil {
+		return fixedpoint.Zero
+	}
+
+	if c.QuotingDepth.Sign() > 0 {
+		return c.QuotingDepth
+	}
+
+	if c.QuotingDepthInQuote.Sign() > 0 && latestPrice.Sign() > 0 {
+		return c.QuotingDepthInQuote.Div(latestPrice)
+	}
+
+	return fixedpoint.Zero
+}
+
 func InitializeHedgeMarketFromConfig(
 	c *HedgeMarketConfig,
 	sessions map[string]*bbgo.ExchangeSession,
@@ -459,9 +503,44 @@ func (m *HedgeMarket) GetQuotePriceBySessionBalances() (bid, ask fixedpoint.Valu
 	// fetch available balances once
 	baseAvail, quoteAvail := m.GetBaseQuoteAvailableBalances()
 
+	// determine a latest price for converting depths between base and quote
+	bestBid := m.bidPricer(0, fixedpoint.Zero)
+	bestAsk := m.askPricer(0, fixedpoint.Zero)
+	latest := fixedpoint.Zero
+	if bestBid.Sign() > 0 && bestAsk.Sign() > 0 {
+		latest = bestBid.Add(bestAsk).Div(fixedpoint.NewFromFloat(2))
+	} else if bestBid.Sign() > 0 {
+		latest = bestBid
+	} else if bestAsk.Sign() > 0 {
+		latest = bestAsk
+	}
+
+	// resolve configured quoting depths in both currencies
+	cfgQuoteDepth := m.HedgeMarketConfig.ResolveQuotingDepthInQuote(latest)
+	cfgBaseDepth := m.HedgeMarketConfig.ResolveQuotingDepthInBase(latest)
+
+	// use min(balance, configuredDepth) per requirement
+	baseDepthToUse := baseAvail
+	if cfgBaseDepth.Sign() > 0 && baseAvail.Compare(cfgBaseDepth) > 0 {
+		baseDepthToUse = cfgBaseDepth
+	}
+
+	quoteDepthToUse := quoteAvail
+	if cfgQuoteDepth.Sign() > 0 && quoteAvail.Compare(cfgQuoteDepth) > 0 {
+		quoteDepthToUse = cfgQuoteDepth
+	}
+
 	// compute raw prices using side-specific depth definitions
-	rawBid := m.depthBook.PriceAtDepth(types.SideTypeBuy, baseAvail)
-	rawAsk := m.depthBook.PriceAtQuoteDepth(types.SideTypeSell, quoteAvail)
+	rawBid := m.depthBook.PriceAtDepth(types.SideTypeBuy, baseDepthToUse)
+	rawAsk := m.depthBook.PriceAtQuoteDepth(types.SideTypeSell, quoteDepthToUse)
+
+	// fallback to best prices if depth-based prices are not available
+	if rawBid.IsZero() {
+		rawBid = bestBid
+	}
+	if rawAsk.IsZero() {
+		rawAsk = bestAsk
+	}
 
 	// Apply fee according to PriceFeeMode
 	feeRate := m.priceFeeRate()
@@ -472,8 +551,12 @@ func (m *HedgeMarket) GetQuotePriceBySessionBalances() (bid, ask fixedpoint.Valu
 	if bid.IsZero() || ask.IsZero() {
 		bids := m.book.SideBook(types.SideTypeBuy)
 		asks := m.book.SideBook(types.SideTypeSell)
-		m.logger.Warnf("no valid bid/ask price from session balances for %s, baseAvail=%s, quoteAvail=%s, bids: %v, asks: %v",
-			m.SymbolSelector, baseAvail.String(), quoteAvail.String(), bids, asks)
+		m.logger.Warnf("no valid bid/ask price from session balances for %s, baseAvail=%s, quoteAvail=%s, cfgBaseDepth=%s, cfgQuoteDepth=%s, usedBaseDepth=%s, usedQuoteDepth=%s, bids: %v, asks: %v",
+			m.SymbolSelector,
+			baseAvail.String(), quoteAvail.String(),
+			cfgBaseDepth.String(), cfgQuoteDepth.String(),
+			baseDepthToUse.String(), quoteDepthToUse.String(),
+			bids, asks)
 	}
 
 	// store prices as snapshot

pkg/strategy/xmaker/hedgemarket_config_test.go

@@ -0,0 +1,93 @@
+package xmaker
+
+import (
+	"testing"
+
+	"github.com/c9s/bbgo/pkg/fixedpoint"
+)
+
+func TestResolveQuotingDepthInQuote(t *testing.T) {
+	price := fixedpoint.NewFromFloat(30000)
+
+	t.Run("prefer in-quote when set", func(t *testing.T) {
+		c := &HedgeMarketConfig{
+			QuotingDepthInQuote: fixedpoint.NewFromFloat(500),
+			QuotingDepth:        fixedpoint.NewFromFloat(2), // should be ignored
+		}
+		got := c.ResolveQuotingDepthInQuote(price)
+		want := fixedpoint.NewFromFloat(500)
+		if got.Compare(want) != 0 {
+			t.Fatalf("got %s, want %s", got.String(), want.String())
+		}
+	})
+
+	t.Run("derive in-quote from base when only base set", func(t *testing.T) {
+		c := &HedgeMarketConfig{
+			QuotingDepth: fixedpoint.NewFromFloat(2),
+		}
+		got := c.ResolveQuotingDepthInQuote(price)
+		want := fixedpoint.NewFromFloat(60000)
+		if got.Compare(want) != 0 {
+			t.Fatalf("got %s, want %s", got.String(), want.String())
+		}
+	})
+
+	t.Run("zero when no config", func(t *testing.T) {
+		c := &HedgeMarketConfig{}
+		got := c.ResolveQuotingDepthInQuote(price)
+		if !got.IsZero() {
+			t.Fatalf("expected zero, got %s", got.String())
+		}
+	})
+
+	t.Run("zero when price is zero and only base set", func(t *testing.T) {
+		c := &HedgeMarketConfig{QuotingDepth: fixedpoint.NewFromFloat(1)}
+		got := c.ResolveQuotingDepthInQuote(fixedpoint.Zero)
+		if !got.IsZero() {
+			t.Fatalf("expected zero, got %s", got.String())
+		}
+	})
+}
+
+func TestResolveQuotingDepthInBase(t *testing.T) {
+	price := fixedpoint.NewFromFloat(25000)
+
+	t.Run("prefer base when set", func(t *testing.T) {
+		c := &HedgeMarketConfig{
+			QuotingDepth:        fixedpoint.NewFromFloat(3),
+			QuotingDepthInQuote: fixedpoint.NewFromFloat(1000), // ignored
+		}
+		got := c.ResolveQuotingDepthInBase(price)
+		want := fixedpoint.NewFromFloat(3)
+		if got.Compare(want) != 0 {
+			t.Fatalf("got %s, want %s", got.String(), want.String())
+		}
+	})
+
+	t.Run("derive base from in-quote when only in-quote set", func(t *testing.T) {
+		c := &HedgeMarketConfig{
+			QuotingDepthInQuote: fixedpoint.NewFromFloat(50000),
+		}
+		got := c.ResolveQuotingDepthInBase(price)
+		want := fixedpoint.NewFromFloat(2)
+		if got.Compare(want) != 0 {
+			t.Fatalf("got %s, want %s", got.String(), want.String())
+		}
+	})
+
+	t.Run("zero when no config", func(t *testing.T) {
+		c := &HedgeMarketConfig{}
+		got := c.ResolveQuotingDepthInBase(price)
+		if !got.IsZero() {
+			t.Fatalf("expected zero, got %s", got.String())
+		}
+	})
+
+	t.Run("zero when price is zero and only in-quote set", func(t *testing.T) {
+		c := &HedgeMarketConfig{QuotingDepthInQuote: fixedpoint.NewFromFloat(1)}
+		got := c.ResolveQuotingDepthInBase(fixedpoint.Zero)
+		if !got.IsZero() {
+			t.Fatalf("expected zero, got %s", got.String())
+		}
+	})
+}

pkg/strategy/xmaker/metrics.go

@@ -143,6 +143,14 @@ var directionAlignedWeight = prometheus.NewGaugeVec(
 	[]string{"strategy_type", "strategy_id", "exchange", "symbol"},
 )
 
+var splitHedgeBidHigherThanAskCounter = prometheus.NewCounterVec(
+	prometheus.CounterOpts{
+		Name: "xmaker_split_hedge_bid_higher_than_ask_total",
+		Help: "The total number of times the split hedge bid price was higher than the ask price",
+	},
+	[]string{"strategy_type", "strategy_id", "exchange", "symbol"},
+)
+
 func init() {
 	prometheus.MustRegister(
 		openOrderBidExposureInUsdMetrics,
@@ -166,5 +174,6 @@ func init() {
 		divergenceD2,
 		directionMean,
 		directionAlignedWeight,
+		splitHedgeBidHigherThanAskCounter,
 	)
 }

pkg/strategy/xmaker/splithedge.go

@@ -347,14 +347,19 @@ func (h *SplitHedge) Stop(shutdownCtx context.Context) error {
 // - Ask side is weighted by base currency available balance of each hedge market session.
 // - Bid side is weighted by quote currency available balance of each hedge market session.
 //
+// For margin accounts (mkt.session.Margin is true):
+// - The debt quota (borrowing capacity) is included in the weight.
+// - Bid weight = quoteAvail + debtQuota.
+// - Ask weight = baseAvail + (debtQuota / askPrice).
+//
 // Per-market prices are obtained by calling HedgeMarket.GetQuotePriceBySessionBalances(),
 // which already considers the market's current book and the session balances as depth.
 //
 // If the total weight for a side is zero (e.g., no base balances for ask weighting), the
 // corresponding returned price will be zero.
-func (h *SplitHedge) GetBalanceWeightedQuotePrice() (bid, ask fixedpoint.Value) {
+func (h *SplitHedge) GetBalanceWeightedQuotePrice() (bid, ask fixedpoint.Value, ret bool) {
 	if h == nil || len(h.hedgeMarketInstances) == 0 {
-		return fixedpoint.Zero, fixedpoint.Zero
+		return fixedpoint.Zero, fixedpoint.Zero, false
 	}
 
 	var (
@@ -371,22 +376,40 @@ func (h *SplitHedge) GetBalanceWeightedQuotePrice() (bid, ask fixedpoint.Value)
 		// Skip markets that have no book-derived prices (but still allow zero balances to contribute zero weight)
 		b, a := mkt.GetQuotePriceBySessionBalances()
 
-		if !a.IsZero() && baseAvail.Sign() > 0 {
-			sumWeightedAsk = sumWeightedAsk.Add(a.Mul(baseAvail))
-			sumBaseWeight = sumBaseWeight.Add(baseAvail)
-		} else if baseAvail.Sign() > 0 && a.IsZero() {
+		if h.logger != nil {
+			h.logger.Infof("splitHedge market ticker: %s ask / bid = %s / %s", name, a.String(), b.String())
+		}
+
+		bidWeight := quoteAvail
+		askWeight := baseAvail
+
+		if mkt.session.Margin {
+			debtQuota := mkt.getDebtQuota()
+			if debtQuota.Sign() > 0 {
+				bidWeight = bidWeight.Add(debtQuota)
+
+				if !a.IsZero() {
+					askWeight = askWeight.Add(debtQuota.Div(a))
+				}
+			}
+		}
+
+		if !a.IsZero() && askWeight.Sign() > 0 {
+			sumWeightedAsk = sumWeightedAsk.Add(a.Mul(askWeight))
+			sumBaseWeight = sumBaseWeight.Add(askWeight)
+		} else if askWeight.Sign() > 0 && a.IsZero() {
 			// helpful diagnostics for missing price with weight
 			if h.logger != nil {
-				h.logger.Warnf("splitHedge: zero ask price from market %s despite positive base balance %s", name, baseAvail.String())
+				h.logger.Warnf("splitHedge: zero ask price from market %s despite positive base balance %s", name, askWeight.String())
 			}
 		}
 
-		if !b.IsZero() && quoteAvail.Sign() > 0 {
-			sumWeightedBid = sumWeightedBid.Add(b.Mul(quoteAvail))
-			sumQuoteWeight = sumQuoteWeight.Add(quoteAvail)
-		} else if quoteAvail.Sign() > 0 && b.IsZero() {
+		if !b.IsZero() && bidWeight.Sign() > 0 {
+			sumWeightedBid = sumWeightedBid.Add(b.Mul(bidWeight))
+			sumQuoteWeight = sumQuoteWeight.Add(bidWeight)
+		} else if bidWeight.Sign() > 0 && b.IsZero() {
 			if h.logger != nil {
-				h.logger.Warnf("splitHedge: zero bid price from market %s despite positive quote balance %s", name, quoteAvail.String())
+				h.logger.Warnf("splitHedge: zero bid price from market %s despite positive quote balance %s", name, bidWeight.String())
 			}
 		}
 	}
@@ -409,5 +432,5 @@ func (h *SplitHedge) GetBalanceWeightedQuotePrice() (bid, ask fixedpoint.Value)
 		}
 	}
 
-	return bid, ask
+	return bid, ask, true
 }