feat: add MTLAX (Synthetic) token category to home page

Add a new Synthetic section for MTLAX token holders, displayed between
Persons and Corporate on the home page. Since the MTLAX RFC is not yet
accepted, we show ALL accounts with an MTLAX trustline (even 0 balance)
to demonstrate community interest, using a nullable mtlax_balance column
to distinguish "no trustline" (NULL) from "has trustline with 0 balance".

- Add TokenMTLAX constant and database migration for mtlax_balance column
- Fetch MTLAX holders during sync alongside MTLAP/MTLAC
- Add GetSynthetic repository method sorted by reputation score
- Add Synthetic stats card and paginated table section to home page
- Include mtlax_balance in search sort expressions
- Update all tests and regenerate mocks

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

Author: xdefrag

internal/config/config.go

@@ -19,6 +19,9 @@ const (
 	// TokenMTLAC is the asset code for Companies.
 	TokenMTLAC = "MTLAC"
 
+	// TokenMTLAX is the asset code for Synthetic.
+	TokenMTLAX = "MTLAX"
+
 	// DefaultPageLimit is the default number of accounts per page.
 	DefaultPageLimit = 20
 )

internal/database/migrations/006_add_mtlax.sql

@@ -0,0 +1,7 @@
+-- +goose Up
+ALTER TABLE accounts ADD COLUMN mtlax_balance NUMERIC(20, 7) DEFAULT NULL;
+CREATE INDEX idx_accounts_mtlax ON accounts(mtlax_balance) WHERE mtlax_balance IS NOT NULL;
+
+-- +goose Down
+DROP INDEX IF EXISTS idx_accounts_mtlax;
+ALTER TABLE accounts DROP COLUMN IF EXISTS mtlax_balance;

internal/handler/handler.go

@@ -30,6 +30,7 @@ type AccountQuerier interface {
 	GetStats(ctx context.Context) (*repository.Stats, error)
 	GetPersons(ctx context.Context, limit int, offset int) ([]repository.PersonRow, error)
 	GetCorporate(ctx context.Context, limit int, offset int) ([]repository.CorporateRow, error)
+	GetSynthetic(ctx context.Context, limit int, offset int) ([]repository.SyntheticRow, error)
 	GetRelationships(ctx context.Context, accountID string) ([]repository.RelationshipRow, error)
 	GetTrustRatings(ctx context.Context, accountID string) (*repository.TrustRating, error)
 	GetConfirmedRelationships(ctx context.Context, accountID string) (map[string]bool, error)

internal/handler/handler_test.go

@@ -65,6 +65,7 @@ func TestHomeHandler(t *testing.T) {
 			TotalAccounts:  100,
 			TotalPersons:   50,
 			TotalCompanies: 25,
+			TotalSynthetic: 10,
 			TotalXLMValue:  1000000.0,
 		}, nil)
 
@@ -76,6 +77,10 @@ func TestHomeHandler(t *testing.T) {
 			{AccountID: "GDEF", Name: "Test Company", MTLACBalance: 50.0, TotalXLMValue: 5000.0},
 		}, nil)
 
+		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, mock.Anything).Return([]repository.SyntheticRow{
+			{AccountID: "GHIJ", Name: "Test Synthetic", ReputationScore: 3.5, ReputationWeight: 10.0},
+		}, nil)
+
 		var renderedData any
 		tmpl.EXPECT().Render(mock.Anything, "home.html", mock.Anything).Run(func(w io.Writer, name string, data any) {
 			renderedData = data
@@ -95,6 +100,7 @@ func TestHomeHandler(t *testing.T) {
 		assert.Equal(t, 100, homeData.Stats.TotalAccounts)
 		assert.Len(t, homeData.Persons, 1)
 		assert.Len(t, homeData.Corporate, 1)
+		assert.Len(t, homeData.Synthetic, 1)
 	})
 
 	t.Run("pagination parameters parsed correctly", func(t *testing.T) {
@@ -106,6 +112,7 @@ func TestHomeHandler(t *testing.T) {
 		// Expect offset 20 for persons and 40 for corporate
 		accounts.EXPECT().GetPersons(mock.Anything, mock.Anything, 20).Return(nil, nil)
 		accounts.EXPECT().GetCorporate(mock.Anything, mock.Anything, 40).Return(nil, nil)
+		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 		tmpl.EXPECT().Render(mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
 		h, err := New(stellar, accounts, nil, tmpl)
@@ -127,6 +134,7 @@ func TestHomeHandler(t *testing.T) {
 		accounts.EXPECT().GetStats(mock.Anything).Return(&repository.Stats{}, nil)
 		accounts.EXPECT().GetPersons(mock.Anything, mock.Anything, 0).Return(nil, nil)
 		accounts.EXPECT().GetCorporate(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
+		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 		tmpl.EXPECT().Render(mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
 		h, err := New(stellar, accounts, nil, tmpl)
@@ -148,6 +156,7 @@ func TestHomeHandler(t *testing.T) {
 		accounts.EXPECT().GetStats(mock.Anything).Return(&repository.Stats{}, nil)
 		accounts.EXPECT().GetPersons(mock.Anything, mock.Anything, 0).Return(nil, nil)
 		accounts.EXPECT().GetCorporate(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
+		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 		tmpl.EXPECT().Render(mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
 		h, err := New(stellar, accounts, nil, tmpl)
@@ -229,6 +238,7 @@ func TestHomeHandler(t *testing.T) {
 		accounts.EXPECT().GetStats(mock.Anything).Return(&repository.Stats{}, nil)
 		accounts.EXPECT().GetPersons(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 		accounts.EXPECT().GetCorporate(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
+		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 		tmpl.EXPECT().Render(mock.Anything, mock.Anything, mock.Anything).Return(errors.New("template error"))
 
 		h, err := New(stellar, accounts, nil, tmpl)
@@ -256,6 +266,7 @@ func TestHomeHandler(t *testing.T) {
 		accounts.EXPECT().GetStats(mock.Anything).Return(&repository.Stats{}, nil)
 		accounts.EXPECT().GetPersons(mock.Anything, mock.Anything, mock.Anything).Return(persons, nil)
 		accounts.EXPECT().GetCorporate(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
+		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 
 		var renderedData any
 		tmpl.EXPECT().Render(mock.Anything, mock.Anything, mock.Anything).Run(func(w io.Writer, name string, data any) {

internal/handler/home.go

@@ -12,15 +12,19 @@ import (
 
 // HomeData holds data for the home page template.
 type HomeData struct {
-	Stats               *repository.Stats
-	Persons             []repository.PersonRow
-	Corporate           []repository.CorporateRow
-	PersonsOffset       int
-	CorporateOffset     int
-	NextPersonsOffset   int
-	NextCorporateOffset int
-	HasMorePersons      bool
-	HasMoreCorporate    bool
+	Stats                *repository.Stats
+	Persons              []repository.PersonRow
+	Corporate            []repository.CorporateRow
+	Synthetic            []repository.SyntheticRow
+	PersonsOffset        int
+	CorporateOffset      int
+	SyntheticOffset      int
+	NextPersonsOffset    int
+	NextCorporateOffset  int
+	NextSyntheticOffset  int
+	HasMorePersons       bool
+	HasMoreCorporate     bool
+	HasMoreSynthetic     bool
 }
 
 // Home handles the main page showing Persons and Companies.
@@ -43,6 +47,14 @@ func (h *Handler) Home(w http.ResponseWriter, r *http.Request) {
 		}
 		corporateOffset = 0
 	}
+	syntheticOffsetParam := r.URL.Query().Get("synthetic_offset")
+	syntheticOffset, err := strconv.Atoi(syntheticOffsetParam)
+	if err != nil || syntheticOffset < 0 {
+		if syntheticOffsetParam != "" {
+			slog.Debug("invalid synthetic_offset parameter, defaulting to 0", "value", syntheticOffsetParam)
+		}
+		syntheticOffset = 0
+	}
 
 	stats, err := h.accounts.GetStats(ctx)
 	if err != nil {
@@ -65,26 +77,41 @@ func (h *Handler) Home(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	synthetic, err := h.accounts.GetSynthetic(ctx, config.DefaultPageLimit+1, syntheticOffset)
+	if err != nil {
+		slog.Error("failed to fetch synthetic", "offset", syntheticOffset, "error", err)
+		http.Error(w, "Failed to fetch synthetic accounts", http.StatusInternalServerError)
+		return
+	}
+
 	hasMorePersons := len(persons) > config.DefaultPageLimit
 	hasMoreCorporate := len(corporate) > config.DefaultPageLimit
+	hasMoreSynthetic := len(synthetic) > config.DefaultPageLimit
 
 	if hasMorePersons {
 		persons = persons[:config.DefaultPageLimit]
 	}
 	if hasMoreCorporate {
 		corporate = corporate[:config.DefaultPageLimit]
 	}
+	if hasMoreSynthetic {
+		synthetic = synthetic[:config.DefaultPageLimit]
+	}
 
 	data := HomeData{
 		Stats:               stats,
 		Persons:             persons,
 		Corporate:           corporate,
+		Synthetic:           synthetic,
 		PersonsOffset:       personsOffset,
 		CorporateOffset:     corporateOffset,
+		SyntheticOffset:     syntheticOffset,
 		NextPersonsOffset:   personsOffset + config.DefaultPageLimit,
 		NextCorporateOffset: corporateOffset + config.DefaultPageLimit,
+		NextSyntheticOffset: syntheticOffset + config.DefaultPageLimit,
 		HasMorePersons:      hasMorePersons,
 		HasMoreCorporate:    hasMoreCorporate,
+		HasMoreSynthetic:    hasMoreSynthetic,
 	}
 
 	var buf bytes.Buffer

internal/handler/mocks/mock_AccountQuerier.go

@@ -32,6 +32,7 @@ type Stats struct {
 	TotalAccounts  int
 	TotalPersons   int
 	TotalCompanies int
+	TotalSynthetic int
 	TotalXLMValue  float64
 }
 
@@ -52,13 +53,22 @@ type CorporateRow struct {
 	TotalXLMValue float64
 }
 
+// SyntheticRow represents a synthetic account (MTLAX trustline holder) from the database.
+type SyntheticRow struct {
+	AccountID        string
+	Name             string
+	ReputationScore  float64
+	ReputationWeight float64
+}
+
 // GetStats returns aggregate statistics.
 func (r *AccountRepository) GetStats(ctx context.Context) (*Stats, error) {
 	query, args, err := database.QB.
 		Select(
 			"COUNT(*) AS total_accounts",
 			"COUNT(*) FILTER (WHERE mtlap_balance > 0 AND mtlap_balance <= 5) AS total_persons",
 			"COUNT(*) FILTER (WHERE mtlac_balance > 0 AND mtlac_balance <= 4) AS total_companies",
+			"COUNT(*) FILTER (WHERE mtlax_balance IS NOT NULL) AS total_synthetic",
 			"COALESCE(SUM(total_xlm_value), 0) AS total_xlm_value",
 		).
 		From("accounts").
@@ -72,6 +82,7 @@ func (r *AccountRepository) GetStats(ctx context.Context) (*Stats, error) {
 		&stats.TotalAccounts,
 		&stats.TotalPersons,
 		&stats.TotalCompanies,
+		&stats.TotalSynthetic,
 		&stats.TotalXLMValue,
 	)
 	if err != nil {
@@ -164,6 +175,48 @@ func (r *AccountRepository) GetCorporate(ctx context.Context, limit int, offset
 	return corporate, nil
 }
 
+// GetSynthetic returns MTLAX trustline holders sorted by reputation score.
+func (r *AccountRepository) GetSynthetic(ctx context.Context, limit int, offset int) ([]SyntheticRow, error) {
+	query, args, err := database.QB.
+		Select(
+			"a.account_id",
+			"COALESCE(m.data_value, CONCAT(LEFT(a.account_id, 6), '...', RIGHT(a.account_id, 6))) AS name",
+			"COALESCE(rs.weighted_score, 0) AS reputation_score",
+			"COALESCE(rs.total_weight, 0) AS reputation_weight",
+		).
+		From("accounts a").
+		LeftJoin("account_metadata m ON a.account_id = m.account_id AND m.data_key = 'Name' AND m.data_index = ''").
+		LeftJoin("reputation_scores rs ON a.account_id = rs.account_id").
+		Where("a.mtlax_balance IS NOT NULL").
+		OrderBy("COALESCE(rs.weighted_score, 0) DESC", "COALESCE(rs.total_weight, 0) DESC").
+		Limit(uint64(limit)).
+		Offset(uint64(offset)).
+		ToSql()
+	if err != nil {
+		return nil, fmt.Errorf("build synthetic query: %w", err)
+	}
+
+	rows, err := r.pool.Query(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("query synthetic: %w", err)
+	}
+	defer rows.Close()
+
+	var synthetic []SyntheticRow
+	for rows.Next() {
+		var s SyntheticRow
+		if err := rows.Scan(&s.AccountID, &s.Name, &s.ReputationScore, &s.ReputationWeight); err != nil {
+			return nil, fmt.Errorf("scan synthetic: %w", err)
+		}
+		synthetic = append(synthetic, s)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("iterate synthetic rows: %w", err)
+	}
+	return synthetic, nil
+}
+
 // RelationshipRow represents a relationship from the database.
 type RelationshipRow struct {
 	SourceAccountID string
@@ -563,7 +616,7 @@ func (r *AccountRepository) SearchAccounts(ctx context.Context, query string, ta
 	case SearchSortByReputation:
 		// Sort by membership level first (MTLAP/MTLAC balance), then by grade bucket, then by weight
 		qb = qb.OrderBy(
-			"GREATEST(a.mtlap_balance, a.mtlac_balance) DESC",
+			"GREATEST(a.mtlap_balance, a.mtlac_balance, COALESCE(a.mtlax_balance, 0)) DESC",
 			`CASE
 				WHEN COALESCE(rs.weighted_score, 0) >= 3.5 THEN 1
 				WHEN COALESCE(rs.weighted_score, 0) >= 3.0 THEN 2
@@ -577,7 +630,7 @@ func (r *AccountRepository) SearchAccounts(ctx context.Context, query string, ta
 			"COALESCE(rs.total_weight, 0) DESC",
 		)
 	default: // SearchSortByBalance
-		qb = qb.OrderBy("GREATEST(a.mtlap_balance, a.mtlac_balance) DESC", "a.total_xlm_value DESC")
+		qb = qb.OrderBy("GREATEST(a.mtlap_balance, a.mtlac_balance, COALESCE(a.mtlax_balance, 0)) DESC", "a.total_xlm_value DESC")
 	}
 
 	qb = qb.Limit(uint64(limit)).Offset(uint64(offset))

internal/repository/account.go

@@ -413,3 +413,15 @@ func getMTLACBalance(data *AccountData) decimal.Decimal {
 func getNativeBalance(data *AccountData) decimal.Decimal {
 	return findBalance(data.Balances, "XLM", "")
 }
+
+// getMTLAXBalance returns a pointer to the MTLAX balance if the trustline exists, or nil if not.
+// This distinguishes "no trustline" (nil) from "has trustline with 0 balance" (*decimal.Zero).
+func getMTLAXBalance(data *AccountData) *decimal.Decimal {
+	bal, found := lo.Find(data.Balances, func(b Balance) bool {
+		return b.AssetCode == config.TokenMTLAX && b.AssetIssuer == config.TokenIssuer
+	})
+	if !found {
+		return nil
+	}
+	return &bal.Balance
+}