fix: resolve spot and futures symbols via shared resolver

Introduce a shared token symbol resolver for spot and futures lookups while keeping alpha lookup independent, restoring prefix/remap handling and preserving spot-only fallback behavior.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

.gitignore

@@ -1,4 +1,2 @@
 /.env
 /.worktrees/
-.DS_Store
-.idea/

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/crypto-price-bot.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/crypto-price-bot.iml" filepath="$PROJECT_DIR$/.idea/crypto-price-bot.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

docs/superpowers/specs/2026-04-27-market-filenames-data-dimension-design.md

@@ -1,85 +0,0 @@
-# Go filenames consistency design
-
-## Context
-
-The repository has inconsistent `.go` filename semantics in multiple areas (domain-oriented names, endpoint/history-oriented names, mixed singular/plural forms).
-This slows code navigation because filenames do not consistently communicate data dimension or responsibility.
-
-Goal: refactor `.go` filenames across the whole repository to a consistent naming model, and align declaration placement with filename responsibility, without changing runtime behavior.
-
-## Scope
-
-Applies to all `.go` files in the repository.
-
-In scope:
-- Rename `.go` files to consistent, responsibility-first names.
-- Mechanical updates required by rename/move.
-- Move declarations between files when needed so file responsibility is clear.
-
-Out of scope:
-- Any behavior or logic changes.
-- Non-`.go` files.
-- New feature work.
-
-## Requirements
-
-1. `.go` filename naming is consistent across the repository.
-2. Filenames follow responsibility-first conventions:
-   - data-dimension names where applicable (`spot_*`, `futures_*`, etc.)
-   - pluralized collection-oriented files (`*_pairs.go`, `*_prices.go`)
-   - avoid endpoint/history-oriented naming that obscures responsibility.
-3. Declarations in each file match filename responsibility.
-4. No public/package behavior change.
-5. Resulting PR remains reviewable by grouping changes mechanically and keeping logic untouched.
-
-## Design
-
-### Naming model
-
-Use a responsibility-first naming model for all `.go` files:
-- A reader should infer the primary responsibility from filename alone.
-- Prefer domain/data-dimension names over transport/implementation-history names.
-- Use consistent singular/plural convention based on file content (entity vs collection).
-
-### Refactor mechanics
-
-1. Inventory `.go` files by package and classify naming inconsistencies.
-2. Define target filename map package-by-package.
-3. Rename files with git-aware rename operations.
-4. Move declarations when file content does not match filename responsibility.
-5. Keep signatures and bodies unchanged.
-6. Apply only mechanical reference/import updates required by moves.
-
-### Execution strategy for reviewability
-
-- Use focused commits by package or subsystem.
-- Keep each commit behavior-neutral.
-- Separate any necessary declaration moves from broad rename waves when this improves diff readability.
-
-## Error handling and behavior
-
-No new error handling paths are introduced.
-Existing control flow and error behavior remain unchanged.
-
-## Testing and verification
-
-1. Run project tests after each major package/subsystem batch.
-2. Run full project test command before PR.
-3. Confirm no functional diff beyond rename/move/mechanical updates.
-4. Final check: each renamed file contains declarations aligned with its responsibility.
-
-## Risks and mitigations
-
-- Risk: accidental behavior change while moving declarations.
-  - Mitigation: keep signatures/bodies unchanged and validate with tests per batch.
-- Risk: review noise from repo-wide scope.
-  - Mitigation: package-grouped commits, strict mechanical-only edits, and explicit PR summary.
-- Risk: large PR becomes hard to review.
-  - Mitigation: preserve commit structure and provide a clear rename map in PR description.
-
-## Success criteria
-
-- `.go` filenames are consistent and responsibility-first across the repo.
-- Declarations in each file align with filename responsibility.
-- Tests pass with no behavior regression.
-- PR is understandable through structured, behavior-neutral commits.

internal/configs/binance/asset.go

@@ -1,21 +1,11 @@
 package binance
 
 var SymbolPrefixList = []string{"1000000", "1000", "1M"}
-
-var SymbolSuffixList = []string{"USDT", "USDC", "FDUSD"}
-
 var SymbolSuffixMap = map[string]string{
-	"USDT":  "",
-	"USDC":  "c",
-	"FDUSD": "fd",
+	"USDT": "",
+	"USDC": "c",
 }
 
-var QuotePriority = []string{"USDT", "USDC", "FDUSD"}
-
-var FutureToken2SpotTokenMap = map[string]string{
-	"LUNA2": "LUNA",
-}
-
-var SpotToken2FutureTokenMap = map[string]string{
-	"LUNA": "LUNA2",
+var Future2SpotSymbolMap = map[string]string{
+	"LUNA2USDT": "LUNAUSDT",
 }

internal/configs/tele/sticker.go

@@ -8,7 +8,7 @@ const (
 
 var Token2StickerIdxMap = map[string]int{
 	"BNB": 3,
-	"TON": 5,
+	"TON": 7,
 }
 
 var Sticker2TokenMap = map[string]string{

internal/data/imarket.go

@@ -13,12 +13,9 @@ type IMarket interface {
 	// Alpha token methods
 	IsAlphaToken(symbol string) bool
 	GetAlphaToken(symbol string) (market.AlphaTokenInfo, bool)
-	GetAlphaPrice(symbol string) (float64, bool)
 
 	// Trading pair methods
 	IsSpotPair(symbol string) bool
 	IsFuturesPair(symbol string) bool
-	GetSpotSymbolByToken(token string) (string, bool)
-	GetFutureSymbolByToken(token string) (string, bool)
 	RefreshTradingPairCache() error
 }

internal/data/market/alpha_tokens.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/url"
 	"strconv"
 	"time"
 
@@ -55,21 +54,10 @@ type AlphaTokenInfo struct {
 
 // AlphaTokenResponse represents the API response structure
 type AlphaTokenResponse struct {
-	Code          string           `json:"code"`
-	Message       *string          `json:"message"`
-	MessageDetail *string          `json:"messageDetail"`
-	Data          []AlphaTokenInfo `json:"data"`
-}
-
-type AlphaTickerData struct {
-	Price string `json:"price"`
-}
-
-type AlphaTickerResponse struct {
-	Code          string          `json:"code"`
-	Message       *string         `json:"message"`
+	Code         string           `json:"code"`
+	Message      *string          `json:"message"`
 	MessageDetail *string         `json:"messageDetail"`
-	Data          AlphaTickerData `json:"data"`
+	Data         []AlphaTokenInfo `json:"data"`
 }
 
 // GetPrice returns the price as float64
@@ -162,37 +150,3 @@ func (ms *MarketData) IsAlphaToken(symbol string) bool {
 	_, exists := ms.GetAlphaToken(symbol)
 	return exists
 }
-
-func (ms *MarketData) GetAlphaPrice(symbol string) (float64, bool) {
-	const alphaTickerURL = "https://www.binance.com/bapi/defi/v1/public/alpha-trade/ticker"
-
-	client := &http.Client{Timeout: 5 * time.Second}
-	endpoint := alphaTickerURL + "?" + url.Values{"symbol": []string{symbol}}.Encode()
-
-	resp, err := client.Get(endpoint)
-	if err != nil {
-		log.Error().Err(err).Str("symbol", symbol).Msg("Failed to fetch Alpha ticker")
-		return 0, false
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return 0, false
-	}
-
-	var tickerResp AlphaTickerResponse
-	if err := json.NewDecoder(resp.Body).Decode(&tickerResp); err != nil {
-		return 0, false
-	}
-
-	if tickerResp.Code != "000000" {
-		return 0, false
-	}
-
-	price, err := strconv.ParseFloat(tickerResp.Data.Price, 64)
-	if err != nil || price <= 0 {
-		return 0, false
-	}
-
-	return price, true
-}

internal/data/market/futures_pairs.go

@@ -1,65 +0,0 @@
-package market
-
-import (
-	"context"
-	"strings"
-	"time"
-
-	"github.com/rs/zerolog/log"
-)
-
-func (ms *MarketData) refreshFuturePairCache() error {
-	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
-	defer cancel()
-
-	futuresInfo, err := ms.futuresClient.NewExchangeInfoService().Do(ctx)
-	if err != nil {
-		log.Error().Err(err).Msg("Failed to fetch futures exchange info")
-		return err
-	}
-
-	futurePairs := make(map[string]bool, len(futuresInfo.Symbols))
-	futureTokenCandidates := make(map[string][]string)
-	for _, s := range futuresInfo.Symbols {
-		if s.Status != "TRADING" {
-			continue
-		}
-		futurePairs[s.Symbol] = true
-		token := parseTokenFromSymbolByQuotePriority(s.Symbol)
-		if token == "" {
-			continue
-		}
-		token = futureCacheTokenKey(token)
-		futureTokenCandidates[token] = append(futureTokenCandidates[token], s.Symbol)
-	}
-
-	futureToken2Symbol := make(map[string]string, len(futureTokenCandidates))
-	for token, candidates := range futureTokenCandidates {
-		futureToken2Symbol[token] = selectCanonicalSymbolByQuotePriority(token, candidates)
-	}
-
-	ms.pairCacheMutex.Lock()
-	ms.futuresPairs = futurePairs
-	ms.futureToken2Symbol = futureToken2Symbol
-	ms.lastPairCacheUpdate = time.Now()
-	ms.pairCacheMutex.Unlock()
-
-	return nil
-}
-
-func futureCacheTokenKey(token string) string {
-	return strings.ToUpper(token)
-}
-
-func (ms *MarketData) IsFuturesPair(symbol string) bool {
-	ms.pairCacheMutex.RLock()
-	defer ms.pairCacheMutex.RUnlock()
-	return ms.futuresPairs[symbol]
-}
-
-func (ms *MarketData) GetFutureSymbolByToken(token string) (string, bool) {
-	ms.pairCacheMutex.RLock()
-	defer ms.pairCacheMutex.RUnlock()
-	sym, ok := ms.futureToken2Symbol[strings.ToUpper(token)]
-	return sym, ok
-}

internal/data/market/main.go

@@ -13,8 +13,6 @@ type MarketData struct {
 	// Trading pair caches
 	spotPairs           map[string]bool
 	futuresPairs        map[string]bool
-	spotToken2Symbol    map[string]string
-	futureToken2Symbol  map[string]string
 	pairCacheMutex      sync.RWMutex
 	lastPairCacheUpdate time.Time
 
@@ -31,61 +29,27 @@ type MarketData struct {
 func NewMarketData() *MarketData {
 	log.Info().Msg("Start market service")
 	ms := &MarketData{
-		spotPairs:          make(map[string]bool),
-		futuresPairs:       make(map[string]bool),
-		spotToken2Symbol:   make(map[string]string),
-		futureToken2Symbol: make(map[string]string),
-		alphaTokens:        make(map[string]AlphaTokenInfo),
-		spotClient:         binance.NewClient("", ""),
-		futuresClient:      futures.NewClient("", ""),
+		spotPairs:     make(map[string]bool),
+		futuresPairs:  make(map[string]bool),
+		alphaTokens:   make(map[string]AlphaTokenInfo),
+		spotClient:    binance.NewClient("", ""),
+		futuresClient: futures.NewClient("", ""),
 	}
 
-	ms.refreshAllCaches()
-	go ms.cacheRefreshLoop()
+	if err := ms.refreshTradingPairCache(); err != nil {
+		log.Error().Err(err).Msg("Failed initial trading pair cache load")
+	}
+	go ms.pairCacheRefreshLoop()
+	go ms.alphaCacheRefreshLoop()
 
 	return ms
 }
 
-func (ms *MarketData) refreshTradingPairCache() error {
-	if err := ms.refreshSpotPairCache(); err != nil {
-		return err
-	}
-	if err := ms.refreshFuturePairCache(); err != nil {
-		return err
-	}
-
-	ms.pairCacheMutex.RLock()
-	spotCount := len(ms.spotPairs)
-	futureCount := len(ms.futuresPairs)
-	ms.pairCacheMutex.RUnlock()
-
-	log.Info().
-		Int("spot", spotCount).
-		Int("futures", futureCount).
-		Msg("Trading pair cache refreshed")
-
-	return nil
-}
-
-func (ms *MarketData) cacheRefreshLoop() {
-	ms.refreshAllCaches()
+func (ms *MarketData) alphaCacheRefreshLoop() {
+	ms.refreshAlphaTokenCache()
 	ticker := time.NewTicker(time.Hour)
 	defer ticker.Stop()
 	for range ticker.C {
-		ms.refreshAllCaches()
+		ms.refreshAlphaTokenCache()
 	}
 }
-
-func (ms *MarketData) refreshAllCaches() {
-	if err := ms.refreshSpotPairCache(); err != nil {
-		log.Error().Err(err).Msg("Failed spot pair refresh")
-	}
-	if err := ms.refreshFuturePairCache(); err != nil {
-		log.Error().Err(err).Msg("Failed futures pair refresh")
-	}
-	ms.refreshAlphaTokenCache()
-}
-
-func (ms *MarketData) RefreshTradingPairCache() error {
-	return ms.refreshTradingPairCache()
-}

internal/data/market/pairs_test.go

@@ -1,41 +0,0 @@
-package market
-
-import "testing"
-
-func TestSelectCanonicalSymbolByQuotePriority(t *testing.T) {
-	pairs := []string{"DOGEFDUSD", "DOGEUSDC", "DOGEUSDT"}
-	got := selectCanonicalSymbolByQuotePriority("DOGE", pairs)
-	if got != "DOGEUSDT" {
-		t.Fatalf("expected DOGEUSDT, got %q", got)
-	}
-}
-
-func TestSelectCanonicalSymbolByQuotePriority_FallbackOrder(t *testing.T) {
-	pairs := []string{"DOGEFDUSD", "DOGEUSDC"}
-	got := selectCanonicalSymbolByQuotePriority("DOGE", pairs)
-	if got != "DOGEUSDC" {
-		t.Fatalf("expected DOGEUSDC, got %q", got)
-	}
-}
-
-func TestSelectCanonicalSymbolByQuotePriority_NoPreferredQuote(t *testing.T) {
-	pairs := []string{"DOGEBUSD"}
-	got := selectCanonicalSymbolByQuotePriority("DOGE", pairs)
-	if got != "DOGEBUSD" {
-		t.Fatalf("expected DOGEBUSD, got %q", got)
-	}
-}
-
-func TestFutureCacheTokenKey_PreservesRawFutureToken(t *testing.T) {
-	got := futureCacheTokenKey("LUNA2")
-	if got != "LUNA2" {
-		t.Fatalf("expected LUNA2, got %q", got)
-	}
-}
-
-func TestFutureCacheTokenKey_NoOverride(t *testing.T) {
-	got := futureCacheTokenKey("PEPE")
-	if got != "PEPE" {
-		t.Fatalf("expected PEPE, got %q", got)
-	}
-}

internal/data/market/spot_pairs.go

@@ -1,103 +0,0 @@
-package market
-
-import (
-	"context"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/rs/zerolog/log"
-	"me.thuanle/bbot/internal/configs/binance"
-)
-
-func (ms *MarketData) refreshSpotPairCache() error {
-	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
-	defer cancel()
-
-	spotInfo, err := ms.spotClient.NewExchangeInfoService().Do(ctx)
-	if err != nil {
-		log.Error().Err(err).Msg("Failed to fetch spot exchange info")
-		return err
-	}
-
-	spotPairs := make(map[string]bool, len(spotInfo.Symbols))
-	spotTokenCandidates := make(map[string][]string)
-	for _, s := range spotInfo.Symbols {
-		if s.Status != "TRADING" {
-			continue
-		}
-		spotPairs[s.Symbol] = true
-		token := parseTokenFromSymbolByQuotePriority(s.Symbol)
-		if token == "" {
-			continue
-		}
-		spotTokenCandidates[token] = append(spotTokenCandidates[token], s.Symbol)
-	}
-
-	spotToken2Symbol := make(map[string]string, len(spotTokenCandidates))
-	for token, candidates := range spotTokenCandidates {
-		spotToken2Symbol[token] = selectCanonicalSymbolByQuotePriority(token, candidates)
-	}
-
-	ms.pairCacheMutex.Lock()
-	ms.spotPairs = spotPairs
-	ms.spotToken2Symbol = spotToken2Symbol
-	ms.lastPairCacheUpdate = time.Now()
-	ms.pairCacheMutex.Unlock()
-
-	return nil
-}
-
-func parseTokenFromSymbolByQuotePriority(symbol string) string {
-	symbol = strings.ToUpper(symbol)
-	for _, quote := range binance.QuotePriority {
-		quote = strings.ToUpper(quote)
-		if strings.HasSuffix(symbol, quote) {
-			token := strings.TrimSuffix(symbol, quote)
-			if token != "" {
-				return token
-			}
-		}
-	}
-	return ""
-}
-
-func selectCanonicalSymbolByQuotePriority(token string, candidates []string) string {
-	if len(candidates) == 0 {
-		return ""
-	}
-	if len(candidates) == 1 {
-		return strings.ToUpper(candidates[0])
-	}
-
-	token = strings.ToUpper(token)
-	normalized := make([]string, 0, len(candidates))
-	for _, c := range candidates {
-		normalized = append(normalized, strings.ToUpper(c))
-	}
-
-	for _, quote := range binance.QuotePriority {
-		target := token + strings.ToUpper(quote)
-		for _, c := range normalized {
-			if c == target {
-				return c
-			}
-		}
-	}
-
-	sort.Strings(normalized)
-	return normalized[0]
-}
-
-func (ms *MarketData) IsSpotPair(symbol string) bool {
-	ms.pairCacheMutex.RLock()
-	defer ms.pairCacheMutex.RUnlock()
-	return ms.spotPairs[symbol]
-}
-
-func (ms *MarketData) GetSpotSymbolByToken(token string) (string, bool) {
-	ms.pairCacheMutex.RLock()
-	defer ms.pairCacheMutex.RUnlock()
-	sym, ok := ms.spotToken2Symbol[strings.ToUpper(token)]
-	return sym, ok
-}

internal/data/market/trading_pairs.go

@@ -0,0 +1,74 @@
+package market
+
+import (
+	"context"
+	"time"
+
+	"github.com/rs/zerolog/log"
+)
+
+func (ms *MarketData) refreshTradingPairCache() error {
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+
+	spotInfo, err := ms.spotClient.NewExchangeInfoService().Do(ctx)
+	if err != nil {
+		log.Error().Err(err).Msg("Failed to fetch spot exchange info")
+		return err
+	}
+
+	futuresInfo, err := ms.futuresClient.NewExchangeInfoService().Do(ctx)
+	if err != nil {
+		log.Error().Err(err).Msg("Failed to fetch futures exchange info")
+		return err
+	}
+
+	ms.pairCacheMutex.Lock()
+	defer ms.pairCacheMutex.Unlock()
+
+	ms.spotPairs = make(map[string]bool, len(spotInfo.Symbols))
+	for _, s := range spotInfo.Symbols {
+		if s.Status == "TRADING" {
+			ms.spotPairs[s.Symbol] = true
+		}
+	}
+
+	ms.futuresPairs = make(map[string]bool, len(futuresInfo.Symbols))
+	for _, s := range futuresInfo.Symbols {
+		if s.Status == "TRADING" {
+			ms.futuresPairs[s.Symbol] = true
+		}
+	}
+
+	ms.lastPairCacheUpdate = time.Now()
+	log.Info().
+		Int("spot", len(ms.spotPairs)).
+		Int("futures", len(ms.futuresPairs)).
+		Msg("Trading pair cache refreshed")
+	return nil
+}
+
+func (ms *MarketData) pairCacheRefreshLoop() {
+	ms.refreshTradingPairCache()
+	ticker := time.NewTicker(time.Hour)
+	defer ticker.Stop()
+	for range ticker.C {
+		ms.refreshTradingPairCache()
+	}
+}
+
+func (ms *MarketData) IsSpotPair(symbol string) bool {
+	ms.pairCacheMutex.RLock()
+	defer ms.pairCacheMutex.RUnlock()
+	return ms.spotPairs[symbol]
+}
+
+func (ms *MarketData) IsFuturesPair(symbol string) bool {
+	ms.pairCacheMutex.RLock()
+	defer ms.pairCacheMutex.RUnlock()
+	return ms.futuresPairs[symbol]
+}
+
+func (ms *MarketData) RefreshTradingPairCache() error {
+	return ms.refreshTradingPairCache()
+}

internal/helper/binancex/resolver.go

@@ -3,60 +3,20 @@ package binancex
 import (
 	"strings"
 
-	"me.thuanle/bbot/internal/configs/binance"
 	"me.thuanle/bbot/internal/data"
-	"me.thuanle/bbot/internal/utils/stringx"
 )
 
 func Token2FutureSymbols(token string) []string {
-	if !stringx.IsAlphaNumeric(token) {
-		return nil
-	}
-
-	token = strings.ToUpper(token)
-	if mapped, ok := data.Market.GetFutureSymbolByToken(token); ok {
-		return []string{mapped}
-	}
-
-	if futureToken, ok := binance.SpotToken2FutureTokenMap[token]; ok {
-		if mapped, ok := data.Market.GetFutureSymbolByToken(strings.ToUpper(futureToken)); ok {
-			return []string{mapped}
-		}
-	}
-
-	return nil
+	return Token2Symbols(token)
 }
 
 func Token2SpotSymbols(token string) []string {
-	if !stringx.IsAlphaNumeric(token) {
-		return nil
-	}
+	futureSymbols := Token2FutureSymbols(token)
+	spots := make([]string, 0, len(futureSymbols)+1)
+	seen := make(map[string]struct{}, len(futureSymbols)+1)
 
-	token = strings.ToUpper(token)
-	if mapped, ok := data.Market.GetSpotSymbolByToken(token); ok {
-		return []string{mapped}
-	}
-
-	return nil
-}
-
-func Token2RelatedSpotSymbols(token string) []string {
-	token = strings.ToUpper(token)
-	seen := make(map[string]struct{}, 2)
-	spots := make([]string, 0, 2)
-
-	for _, futureSymbol := range Token2FutureSymbols(token) {
+	for _, futureSymbol := range futureSymbols {
 		spotSymbol := Future2SpotSymbol(futureSymbol)
-		if _, ok := seen[spotSymbol]; ok {
-			continue
-		}
-		if data.Market.IsSpotPair(spotSymbol) {
-			seen[spotSymbol] = struct{}{}
-			spots = append(spots, spotSymbol)
-		}
-	}
-
-	for _, spotSymbol := range Token2SpotSymbols(token) {
 		if _, ok := seen[spotSymbol]; ok {
 			continue
 		}
@@ -64,5 +24,12 @@ func Token2RelatedSpotSymbols(token string) []string {
 		spots = append(spots, spotSymbol)
 	}
 
+	spotOnly := strings.ToUpper(token) + "USDT"
+	if data.Market.IsSpotPair(spotOnly) {
+		if _, ok := seen[spotOnly]; !ok {
+			spots = append(spots, spotOnly)
+		}
+	}
+
 	return spots
 }

internal/helper/binancex/resolver_test.go

@@ -1,16 +1,13 @@
 package binancex
 
 import (
-	"strings"
 	"testing"
 
-	"me.thuanle/bbot/internal/configs/binance"
 	"me.thuanle/bbot/internal/data"
 	"me.thuanle/bbot/internal/data/market"
 )
 
 type resolverMarketStub struct {
-	alphaTokens  map[string]bool
 	spotPairs    map[string]bool
 	futuresPairs map[string]bool
 }
@@ -22,178 +19,70 @@ func (m *resolverMarketStub) GetAllPremiumIndex() (map[string]market.PremiumInde
 	return nil, nil
 }
 func (m *resolverMarketStub) GetAllFundRate() (map[string]float64, map[string]int64) { return nil, nil }
-func (m *resolverMarketStub) GetSpotPrice(symbol string) (float64, bool)             { return 0, false }
-func (m *resolverMarketStub) GetMarginInterestRates() map[string]float64             { return nil }
-func (m *resolverMarketStub) IsAlphaToken(symbol string) bool                        { return m.alphaTokens[symbol] }
+func (m *resolverMarketStub) GetSpotPrice(symbol string) (float64, bool)              { return 0, false }
+func (m *resolverMarketStub) GetMarginInterestRates() map[string]float64              { return nil }
+func (m *resolverMarketStub) IsAlphaToken(symbol string) bool                          { return false }
 func (m *resolverMarketStub) GetAlphaToken(symbol string) (market.AlphaTokenInfo, bool) {
 	return market.AlphaTokenInfo{}, false
 }
-func (m *resolverMarketStub) GetAlphaPrice(symbol string) (float64, bool) { return 0, false }
-func (m *resolverMarketStub) IsSpotPair(symbol string) bool               { return m.spotPairs[symbol] }
-func (m *resolverMarketStub) IsFuturesPair(symbol string) bool            { return m.futuresPairs[symbol] }
-func (m *resolverMarketStub) GetSpotSymbolByToken(token string) (string, bool) {
-	token = strings.ToUpper(token)
-	for sym := range m.spotPairs {
-		if strings.ToUpper(Symbol2Token(sym)) == token {
-			return sym, true
-		}
-	}
-	return "", false
-}
-func (m *resolverMarketStub) GetFutureSymbolByToken(token string) (string, bool) {
-	token = strings.ToUpper(token)
-	for sym := range m.futuresPairs {
-		if strings.ToUpper(Symbol2Token(sym)) == token {
-			return sym, true
-		}
-	}
-	return "", false
-}
-func (m *resolverMarketStub) RefreshTradingPairCache() error { return nil }
+func (m *resolverMarketStub) IsSpotPair(symbol string) bool    { return m.spotPairs[symbol] }
+func (m *resolverMarketStub) IsFuturesPair(symbol string) bool { return m.futuresPairs[symbol] }
+func (m *resolverMarketStub) RefreshTradingPairCache() error   { return nil }
 
-func withResolverMarketStub(t *testing.T, marketStub *resolverMarketStub) {
-	t.Helper()
+func TestToken2FutureSymbols_ResolvesPrefixAndSuffix(t *testing.T) {
 	orig := data.Market
-	data.Market = marketStub
-	t.Cleanup(func() { data.Market = orig })
-}
+	defer func() { data.Market = orig }()
 
-func TestToken2FutureSymbols_ReturnsCanonicalFutureSymbol(t *testing.T) {
-	withResolverMarketStub(t, &resolverMarketStub{
+	data.Market = &resolverMarketStub{
 		futuresPairs: map[string]bool{
 			"1000PEPEUSDT": true,
 			"1000PEPEUSDC": true,
 		},
-	})
+	}
 
 	syms := Token2FutureSymbols("pepe")
-	if len(syms) != 1 || syms[0] != "1000PEPEUSDT" {
-		t.Fatalf("expected canonical [1000PEPEUSDT], got %+v", syms)
+	if len(syms) == 0 {
+		t.Fatalf("expected future symbols for PEPE")
 	}
-}
 
-func TestToken2FutureSymbols_UsesCanonicalQuotePriority(t *testing.T) {
-	withResolverMarketStub(t, &resolverMarketStub{
-		futuresPairs: map[string]bool{
-			"1000PEPEUSDT": true,
-			"1000PEPEUSDC": true,
-			"PEPEUSDT":     true,
-			"PEPEUSDC":     true,
-		},
-	})
-
-	syms := Token2FutureSymbols("pepe")
-	if len(syms) != 1 || syms[0] != "1000PEPEUSDT" {
-		t.Fatalf("expected canonical [1000PEPEUSDT], got %+v", syms)
-	}
-}
-
-func TestToken2FutureSymbols_ResolvesUSDCAbbreviation(t *testing.T) {
-	withResolverMarketStub(t, &resolverMarketStub{
-		futuresPairs: map[string]bool{"PEPEUSDC": true},
-	})
-
-	syms := Token2FutureSymbols("pepec")
-	if len(syms) != 1 || syms[0] != "PEPEUSDC" {
-		t.Fatalf("expected [PEPEUSDC], got %+v", syms)
-	}
-}
-
-func TestSymbolSuffixListMatchesSymbolSuffixMap(t *testing.T) {
-	seen := make(map[string]struct{}, len(binance.SymbolSuffixList))
-	for _, suffix := range binance.SymbolSuffixList {
-		if _, ok := binance.SymbolSuffixMap[suffix]; !ok {
-			t.Fatalf("SymbolSuffixList contains %q missing from SymbolSuffixMap", suffix)
+	foundUSDT := false
+	foundUSDC := false
+	for _, sym := range syms {
+		if sym == "1000PEPEUSDT" {
+			foundUSDT = true
 		}
-		seen[suffix] = struct{}{}
-	}
-
-	for suffix := range binance.SymbolSuffixMap {
-		if _, ok := seen[suffix]; !ok {
-			t.Fatalf("SymbolSuffixMap contains %q missing from SymbolSuffixList", suffix)
+		if sym == "1000PEPEUSDC" {
+			foundUSDC = true
 		}
 	}
-}
 
-func TestIsToken(t *testing.T) {
-	tests := []struct {
-		name       string
-		input      string
-		marketStub *resolverMarketStub
-		want       bool
-	}{
-		{
-			name:  "futures token resolution success",
-			input: "pepe",
-			marketStub: &resolverMarketStub{
-				futuresPairs: map[string]bool{"1000PEPEUSDT": true},
-			},
-			want: true,
-		},
-		{
-			name:  "alpha token fallback",
-			input: "alpha",
-			marketStub: &resolverMarketStub{
-				alphaTokens: map[string]bool{"ALPHA": true},
-			},
-			want: true,
-		},
-		{
-			name:  "spot only token fallback",
-			input: "abc",
-			marketStub: &resolverMarketStub{
-				spotPairs: map[string]bool{"ABCUSDT": true},
-			},
-			want: true,
-		},
-		{
-			name:       "non alphanumeric input",
-			input:      "bad!",
-			marketStub: &resolverMarketStub{},
-			want:       false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			withResolverMarketStub(t, tt.marketStub)
-
-			got := IsToken(tt.input)
-			if got != tt.want {
-				t.Fatalf("expected %v, got %v", tt.want, got)
-			}
-		})
+	if !foundUSDT || !foundUSDC {
+		t.Fatalf("expected both 1000PEPEUSDT and 1000PEPEUSDC, got %+v", syms)
 	}
 }
 
-func TestToken2SpotSymbols_DoesNotDependOnFutureMappings(t *testing.T) {
-	withResolverMarketStub(t, &resolverMarketStub{
+func TestToken2SpotSymbols_AppliesExplicitRemap(t *testing.T) {
+	orig := data.Market
+	defer func() { data.Market = orig }()
+
+	data.Market = &resolverMarketStub{
 		futuresPairs: map[string]bool{"LUNA2USDT": true},
 		spotPairs:    map[string]bool{"LUNAUSDT": true},
-	})
+	}
 
 	spots := Token2SpotSymbols("luna2")
-	if len(spots) != 0 {
-		t.Fatalf("expected no direct spot symbols for LUNA2, got %+v", spots)
-	}
-}
-
-func TestToken2RelatedSpotSymbols_AppliesExplicitRemap(t *testing.T) {
-	withResolverMarketStub(t, &resolverMarketStub{
-		futuresPairs: map[string]bool{"LUNA2USDT": true},
-		spotPairs:    map[string]bool{"LUNAUSDT": true},
-	})
-
-	spots := Token2RelatedSpotSymbols("luna2")
 	if len(spots) != 1 || spots[0] != "LUNAUSDT" {
 		t.Fatalf("expected [LUNAUSDT], got %+v", spots)
 	}
 }
 
 func TestToken2SpotSymbols_SpotOnlyFallback(t *testing.T) {
-	withResolverMarketStub(t, &resolverMarketStub{
+	orig := data.Market
+	defer func() { data.Market = orig }()
+
+	data.Market = &resolverMarketStub{
 		spotPairs: map[string]bool{"ABCUSDT": true},
-	})
+	}
 
 	spots := Token2SpotSymbols("abc")
 	if len(spots) != 1 || spots[0] != "ABCUSDT" {

internal/helper/binancex/symbol.go

@@ -14,8 +14,7 @@ func Symbol2Token(sym string) string {
 	for _, prefix := range binance.SymbolPrefixList {
 		token, _ = strings.CutPrefix(token, prefix)
 	}
-	for _, suffix := range binance.SymbolSuffixList {
-		abbr := binance.SymbolSuffixMap[suffix]
+	for suffix, abbr := range binance.SymbolSuffixMap {
 		var f bool
 		token, f = stringx.ReplaceSuffix(token, suffix, abbr)
 		if f {
@@ -29,14 +28,58 @@ var (
 	checkingPrefixList = append(binance.SymbolPrefixList, "")
 )
 
-func IsToken(s string) bool {
-	if len(Token2FutureSymbols(s)) > 0 {
-		return true
+func testSym(sym string) bool {
+	return data.Market.IsFuturesPair(sym)
+}
+
+func Token2Symbols(token string) []string {
+	var syms []string
+	if !stringx.IsAlphaNumeric(token) {
+		return syms
 	}
-	if len(Token2SpotSymbols(s)) > 0 {
+
+	token = strings.ToUpper(token)
+
+	for _, prefix := range checkingPrefixList {
+		prefix = strings.ToUpper(prefix)
+
+		s := prefix + token
+
+		//no suffix
+		if testSym(s) {
+			syms = append(syms, s)
+			continue
+		}
+
+		for suffix, abbr := range binance.SymbolSuffixMap {
+			suffix = strings.ToUpper(suffix)
+			abbr = strings.ToUpper(abbr)
+
+			//suffix
+			sym := s + suffix
+			if testSym(sym) {
+				syms = append(syms, sym)
+				continue
+			}
+
+			//suffix abbr
+			symAbr, found := stringx.ReplaceSuffix(s, abbr, suffix)
+			if found && testSym(symAbr) {
+				syms = append(syms, symAbr)
+				continue
+			}
+		}
+	}
+	return syms
+}
+
+func IsToken(s string) bool {
+	// First check regular symbols
+	if len(Token2Symbols(s)) > 0 {
 		return true
 	}
 	
+	// Then check Alpha tokens
 	s = strings.ToUpper(s)
 	return data.Market.IsAlphaToken(s)
 }
@@ -51,9 +94,9 @@ func Future2SpotSymbol(sym string) string {
 		}
 	}
 
-	token := Symbol2Token(sym)
-	if mapped, ok := binance.FutureToken2SpotTokenMap[token]; ok {
-		token = strings.ToUpper(mapped)
+	spotSym, ok := binance.Future2SpotSymbolMap[sym]
+	if !ok {
+		return sym
 	}
-	return token + "USDT"
+	return spotSym
 }

internal/services/tele/commands/token.go

@@ -67,13 +67,9 @@ func collectRichTokenData(token string) buildRichTokenMessageArgs {
 
 	if alphaToken, ok := data.Market.GetAlphaToken(token); ok {
 		a.HasAlpha = true
+		a.AlphaPrice = alphaToken.GetPrice()
 		a.HasAlpha24h = true
 		a.Alpha24h = alphaToken.GetPercentChange24h()
-		if alphaPrice, ok := data.Market.GetAlphaPrice(token + "USDT"); ok {
-			a.AlphaPrice = alphaPrice
-		} else {
-			a.AlphaPrice = alphaToken.GetPrice()
-		}
 	}
 
 	futureSymbols := binancex.Token2FutureSymbols(token)
@@ -87,7 +83,7 @@ func collectRichTokenData(token string) buildRichTokenMessageArgs {
 		}
 	}
 
-	spotSymbols := binancex.Token2RelatedSpotSymbols(token)
+	spotSymbols := binancex.Token2SpotSymbols(token)
 	for _, spotSymbol := range spotSymbols {
 		if sp, ok := data.Market.GetSpotPrice(spotSymbol); ok {
 			a.HasSpot = true
@@ -113,6 +109,7 @@ func OnTokenInfoByToken(context telebot.Context, token string) error {
 	}
 
 	msg := view.RenderRichTokenMessage(buildRichTokenMessageInput(args))
+
 	_ = chat.ReplyMessage(context, msg)
 	return nil
 }

internal/services/tele/commands/token_test.go

@@ -1,14 +1,51 @@
 package commands
 
 import (
-	"strings"
 	"testing"
 
 	"me.thuanle/bbot/internal/data"
 	"me.thuanle/bbot/internal/data/market"
-	"me.thuanle/bbot/internal/helper/binancex"
 )
 
+type marketStub struct {
+	spotPairs    map[string]bool
+	futuresPairs map[string]bool
+	spotPrices   map[string]float64
+	futurePrices map[string]struct {
+		price float64
+		rate  float64
+		time  int64
+	}
+	alphaTokens map[string]market.AlphaTokenInfo
+	marginRates map[string]float64
+}
+
+func (m *marketStub) GetFuturePrice(symbol string) (float64, float64, int64, bool) {
+	v, ok := m.futurePrices[symbol]
+	if !ok {
+		return 0, 0, 0, false
+	}
+	return v.price, v.rate, v.time, true
+}
+func (m *marketStub) GetAllPremiumIndex() (map[string]market.PremiumIndex, error) { return nil, nil }
+func (m *marketStub) GetAllFundRate() (map[string]float64, map[string]int64)      { return nil, nil }
+func (m *marketStub) GetSpotPrice(symbol string) (float64, bool) {
+	v, ok := m.spotPrices[symbol]
+	return v, ok
+}
+func (m *marketStub) GetMarginInterestRates() map[string]float64 { return m.marginRates }
+func (m *marketStub) IsAlphaToken(symbol string) bool {
+	_, ok := m.alphaTokens[symbol]
+	return ok
+}
+func (m *marketStub) GetAlphaToken(symbol string) (market.AlphaTokenInfo, bool) {
+	v, ok := m.alphaTokens[symbol]
+	return v, ok
+}
+func (m *marketStub) IsSpotPair(symbol string) bool    { return m.spotPairs[symbol] }
+func (m *marketStub) IsFuturesPair(symbol string) bool { return m.futuresPairs[symbol] }
+func (m *marketStub) RefreshTradingPairCache() error   { return nil }
+
 func TestBuildRichTokenMessageInput_AllSources(t *testing.T) {
 	in := buildRichTokenMessageInput(buildRichTokenMessageArgs{
 		Token:            "ETH",
@@ -48,68 +85,6 @@ func TestBuildRichTokenMessageInput_OnlyAlpha(t *testing.T) {
 	}
 }
 
-type marketStub struct {
-	spotPairs    map[string]bool
-	futuresPairs map[string]bool
-	spotPrices   map[string]float64
-	futurePrices map[string]struct {
-		price float64
-		rate  float64
-		time  int64
-	}
-	alphaTokens map[string]market.AlphaTokenInfo
-	alphaPrices map[string]float64
-	marginRates map[string]float64
-}
-
-func (m *marketStub) GetFuturePrice(symbol string) (float64, float64, int64, bool) {
-	v, ok := m.futurePrices[symbol]
-	if !ok {
-		return 0, 0, 0, false
-	}
-	return v.price, v.rate, v.time, true
-}
-func (m *marketStub) GetAllPremiumIndex() (map[string]market.PremiumIndex, error) { return nil, nil }
-func (m *marketStub) GetAllFundRate() (map[string]float64, map[string]int64)      { return nil, nil }
-func (m *marketStub) GetSpotPrice(symbol string) (float64, bool) {
-	v, ok := m.spotPrices[symbol]
-	return v, ok
-}
-func (m *marketStub) GetMarginInterestRates() map[string]float64 { return m.marginRates }
-func (m *marketStub) IsAlphaToken(symbol string) bool {
-	_, ok := m.alphaTokens[symbol]
-	return ok
-}
-func (m *marketStub) GetAlphaToken(symbol string) (market.AlphaTokenInfo, bool) {
-	v, ok := m.alphaTokens[symbol]
-	return v, ok
-}
-func (m *marketStub) GetAlphaPrice(symbol string) (float64, bool) {
-	v, ok := m.alphaPrices[symbol]
-	return v, ok
-}
-func (m *marketStub) IsSpotPair(symbol string) bool    { return m.spotPairs[symbol] }
-func (m *marketStub) IsFuturesPair(symbol string) bool { return m.futuresPairs[symbol] }
-func (m *marketStub) GetSpotSymbolByToken(token string) (string, bool) {
-	token = strings.ToUpper(token)
-	for symbol := range m.spotPairs {
-		if binancex.Symbol2Token(symbol) == token {
-			return symbol, true
-		}
-	}
-	return "", false
-}
-func (m *marketStub) GetFutureSymbolByToken(token string) (string, bool) {
-	token = strings.ToUpper(token)
-	for symbol := range m.futuresPairs {
-		if binancex.Symbol2Token(symbol) == token {
-			return symbol, true
-		}
-	}
-	return "", false
-}
-func (m *marketStub) RefreshTradingPairCache() error { return nil }
-
 func TestCollectRichTokenData_SpotOnlyReachable(t *testing.T) {
 	orig := data.Market
 	defer func() { data.Market = orig }()
@@ -219,25 +194,21 @@ func TestCollectRichTokenData_PrefixFutureMapsToSpot(t *testing.T) {
 	}
 }
 
-func TestCollectRichTokenData_AlphaUsesSymbolPrice(t *testing.T) {
+func TestCollectRichTokenData_AlphaIndependent(t *testing.T) {
 	orig := data.Market
 	defer func() { data.Market = orig }()
 
 	data.Market = &marketStub{
 		alphaTokens: map[string]market.AlphaTokenInfo{
-			"ABC": {Symbol: "ABC", PercentChange24h: "12.4", Price: "0.1"},
+			"ABC": {Symbol: "ABC", PercentChange24h: "12.4", Price: "0.1234"},
 		},
-		alphaPrices: map[string]float64{"ABCUSDT": 0.1234},
 	}
 
 	args := collectRichTokenData("ABC")
 	if !args.HasAlpha {
-		t.Fatalf("expected alpha to be available: %+v", args)
+		t.Fatalf("expected alpha source available, got %+v", args)
 	}
-	if !args.HasAlpha24h {
-		t.Fatalf("expected alpha 24h to be available: %+v", args)
-	}
-	if args.AlphaPrice != 0.1234 {
-		t.Fatalf("expected alpha price from symbol lookup, got %.4f", args.AlphaPrice)
+	if args.HasSpot || args.HasFuture {
+		t.Fatalf("expected alpha independent from spot/future, got %+v", args)
 	}
 }

run-tele.sh

@@ -0,0 +1 @@
+go run cmd/tele/main.go                                                                                                                                                                                                                                                                                  ─╯