recomma · terwey · Oct 23, 2025 · Oct 23, 2025
diff --git a/cmd/recomma/main.go b/cmd/recomma/main.go
@@ -171,10 +171,29 @@ func main() {
 	}()
 
 	logger.Debug("Waiting for vault to be unsealed")
-	err = vaultController.WaitUntilUnsealed(appCtx)
-	if err != nil {
-		logger.Warn("vaultController WaitUntilUnsealed returned an error", slog.String("error", err.Error()))
+	unsealedCh := make(chan error, 1)
+	go func() {
+		unsealedCh <- vaultController.WaitUntilUnsealed(appCtx)
+	}()
+
+	select {
+	case err := <-apiErrCh:
+		if err != nil {
+			logger.Error("HTTP server failed before unseal", slog.String("error", err.Error()))
+			os.Exit(1)
+		}
+		logger.Info("HTTP server closed before unseal")
+		os.Exit(0)
+	case <-appCtx.Done():
+		logger.Warn("context cancelled while waiting for vault unseal", slog.String("error", appCtx.Err().Error()))
 		os.Exit(0)
+	case err := <-unsealedCh:
+		if err != nil {
+			if !errors.Is(err, context.Canceled) {
+				logger.Warn("vaultController WaitUntilUnsealed returned an error", slog.String("error", err.Error()))
+			}
+			os.Exit(0)
+		}
 	}
 
 	// we can now access the secrets
@@ -211,6 +230,7 @@ func main() {
 		fatal("Could not create Hyperliquid websocket conn", err)
 	}
 	defer ws.Close()
+	api.WithHyperliquidPriceSource(ws)(apiHandler)
 
 	logger.Info("Service ready", slog.String("baseurl", secrets.Secrets.HYPERLIQUIDURL))
 
@@ -233,6 +253,7 @@ func main() {
 	oq := workqueue.NewTypedRateLimitingQueueWithConfig(rlOrders, oqCfg)
 
 	engineEmitter := emitter.NewQueueEmitter(oq)
+	api.WithOrderEmitter(engineEmitter)(apiHandler)
 	e := engine.NewEngine(client,
 		engine.WithStorage(store),
 		engine.WithEmitter(engineEmitter),

diff --git a/hl/ws/ws.go b/hl/ws/ws.go
@@ -2,8 +2,11 @@ package ws
 
 import (
 	"context"
+	"fmt"
 	"log/slog"
+	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/sonirico/go-hyperliquid"
@@ -17,12 +20,51 @@ type Client struct {
 	ws            *hyperliquid.WebsocketClient
 	subscriptions sync.Map
 	coinBbos      sync.Map
+	bboTopics     sync.Map
 
 	logger  *slog.Logger
 	store   *storage.Storage
 	tracker *filltracker.Service
 }
 
+type bboTopic struct {
+	mu     sync.RWMutex
+	subs   map[int64]chan hl.BestBidOffer
+	nextID int64
+}
+
+func newBBOTopic() *bboTopic {
+	return &bboTopic{
+		subs: make(map[int64]chan hl.BestBidOffer),
+	}
+}
+
+func (t *bboTopic) add(ch chan hl.BestBidOffer) int64 {
+	id := atomic.AddInt64(&t.nextID, 1)
+	t.mu.Lock()
+	t.subs[id] = ch
+	t.mu.Unlock()
+	return id
+}
+
+func (t *bboTopic) remove(id int64) {
+	t.mu.Lock()
+	delete(t.subs, id)
+	t.mu.Unlock()
+}
+
+func (t *bboTopic) broadcast(bbo hl.BestBidOffer) {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	for _, ch := range t.subs {
+		select {
+		case ch <- bbo:
+		default:
+			// Drop when subscriber backlog is full.
+		}
+	}
+}
+
 // New opens a websocket and subscribes to order updates for userAddr.
 // Pass "" for apiURL to use SDK default (mainnet).
 func New(ctx context.Context, store *storage.Storage, tracker *filltracker.Service, userAddr, apiURL string, opts ...hyperliquid.WsOpt) (*Client, error) {
@@ -75,6 +117,10 @@ func New(ctx context.Context, store *storage.Storage, tracker *filltracker.Servi
 }
 
 func (c *Client) EnsureBBO(coin string) {
+	coin = normalizeCoin(coin)
+	if coin == "" {
+		return
+	}
 	if _, ok := c.subscriptions.Load(coin); ok {
 		// exists
 		return
@@ -83,25 +129,42 @@ func (c *Client) EnsureBBO(coin string) {
 	bboSub, err := c.ws.Bbo(hyperliquid.BboSubscriptionParams{Coin: coin},
 		func(bbo hyperliquid.Bbo, err error) {
 			if err != nil {
+				if c.logger != nil {
+					c.logger.Warn("BBO callback error", slog.String("coin", coin), slog.String("error", err.Error()))
+				}
 				return
 			}
 
 			// c.logger.Debug("BBo", slog.String("coin", coin), slog.Any("bbo", bbo))
 			c.storeCoinBBO(coin, hl.WsBBOToBBO(bbo))
 		})
 	if err != nil {
-		c.logger.Warn("could not subscribe to BBO", slog.String("coin", coin))
+		c.logger.Warn("could not subscribe to BBO", slog.String("coin", coin), slog.String("error", err.Error()))
 	}
 
 	c.subscriptions.Store(coin, bboSub)
 }
 
 func (c *Client) storeCoinBBO(coin string, bbo hl.BestBidOffer) {
-	c.coinBbos.Store(coin, bbo)
+	key := normalizeCoin(coin)
+	if key == "" {
+		return
+	}
+	bbo.Coin = key
+	c.coinBbos.Store(key, bbo)
+	if raw, ok := c.bboTopics.Load(key); ok {
+		if topic, ok := raw.(*bboTopic); ok {
+			topic.broadcast(bbo)
+		}
+	}
 }
 
 // WaitForBestBidOffer blocks for a BestBidOffer result until the context reaches a timeout
 func (c *Client) WaitForBestBidOffer(ctx context.Context, coin string) *hl.BestBidOffer {
+	coin = normalizeCoin(coin)
+	if coin == "" {
+		return nil
+	}
 	for {
 		if v, ok := c.coinBbos.Load(coin); ok {
 			if bbo, ok := v.(hl.BestBidOffer); ok {
@@ -117,6 +180,45 @@ func (c *Client) WaitForBestBidOffer(ctx context.Context, coin string) *hl.BestB
 	}
 }
 
+// SubscribeBBO returns a channel that receives best bid/offer updates for the given coin.
+func (c *Client) SubscribeBBO(ctx context.Context, coin string) (<-chan hl.BestBidOffer, error) {
+	coin = normalizeCoin(coin)
+	if coin == "" {
+		return nil, fmt.Errorf("coin is required")
+	}
+
+	c.EnsureBBO(coin)
+	if c.logger != nil {
+		c.logger.Debug("SubscribeBBO", slog.String("coin", coin))
+	}
+
+	topic := c.ensureBBOTopic(coin)
+	if topic == nil {
+		return nil, fmt.Errorf("unable to create subscription topic")
+	}
+
+	ch := make(chan hl.BestBidOffer, 8)
+	id := topic.add(ch)
+
+	if current := c.currentBBO(coin); current != nil {
+		select {
+		case ch <- *current:
+		default:
+		}
+	}
+
+	go func() {
+		<-ctx.Done()
+		topic.remove(id)
+		close(ch)
+		if c.logger != nil {
+			c.logger.Debug("SubscribeBBO closed", slog.String("coin", coin))
+		}
+	}()
+
+	return ch, nil
+}
+
 // Close closes the subscription and websocket.
 func (c *Client) Close() error {
 	c.subscriptions.Range(func(key any, value any) bool {
@@ -151,3 +253,31 @@ func (c *Client) Get(ctx context.Context, md metadata.Metadata) (*hyperliquid.Ws
 
 	return status, ok
 }
+
+func (c *Client) ensureBBOTopic(coin string) *bboTopic {
+	if coin == "" {
+		return nil
+	}
+	actual, _ := c.bboTopics.LoadOrStore(coin, newBBOTopic())
+	if topic, ok := actual.(*bboTopic); ok {
+		return topic
+	}
+	return nil
+}
+
+func (c *Client) currentBBO(coin string) *hl.BestBidOffer {
+	coin = normalizeCoin(coin)
+	if coin == "" {
+		return nil
+	}
+	if v, ok := c.coinBbos.Load(coin); ok {
+		if bbo, ok := v.(hl.BestBidOffer); ok {
+			return &bbo
+		}
+	}
+	return nil
+}
+
+func normalizeCoin(coin string) string {
+	return strings.ToUpper(strings.TrimSpace(coin))
+}