fix: address PR review findings for MTLAX synthetic category

- Fix pagination links in home.html to preserve synthetic_offset across sections
- Add MTLAXBalance field to SyntheticRow and SearchAccountRow for consistency
- Surface MTLAX membership in search results with IsSynthetic flag and [MTLAX] badge
- Add GetSynthetic error test for 500 response
- Add getMTLAXBalance unit tests (nil/zero/non-zero trustline cases)
- Replace mock.Anything with exact offset values in handler tests

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

Author: xdefrag

internal/handler/handler_test.go

@@ -78,7 +78,7 @@ func TestHomeHandler(t *testing.T) {
 		}, nil)
 
 		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, mock.Anything).Return([]repository.SyntheticRow{
-			{AccountID: "GHIJ", Name: "Test Synthetic", ReputationScore: 3.5, ReputationWeight: 10.0},
+			{AccountID: "GHIJ", Name: "Test Synthetic", MTLAXBalance: 1.0, ReputationScore: 3.5, ReputationWeight: 10.0},
 		}, nil)
 
 		var renderedData any
@@ -109,10 +109,10 @@ func TestHomeHandler(t *testing.T) {
 		tmpl := mocks.NewMockTemplateRenderer(t)
 
 		accounts.EXPECT().GetStats(mock.Anything).Return(&repository.Stats{}, nil)
-		// Expect offset 20 for persons and 40 for corporate
+		// Expect offset 20 for persons, 40 for corporate, 0 for synthetic
 		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)
+		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, 0).Return(nil, nil)
 		tmpl.EXPECT().Render(mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
 		h, err := New(stellar, accounts, nil, tmpl)
@@ -133,8 +133,8 @@ 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)
+		accounts.EXPECT().GetCorporate(mock.Anything, mock.Anything, 0).Return(nil, nil)
+		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, 0).Return(nil, nil)
 		tmpl.EXPECT().Render(mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
 		h, err := New(stellar, accounts, nil, tmpl)
@@ -155,8 +155,8 @@ 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)
+		accounts.EXPECT().GetCorporate(mock.Anything, mock.Anything, 0).Return(nil, nil)
+		accounts.EXPECT().GetSynthetic(mock.Anything, mock.Anything, 0).Return(nil, nil)
 		tmpl.EXPECT().Render(mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
 		h, err := New(stellar, accounts, nil, tmpl)
@@ -230,6 +230,28 @@ func TestHomeHandler(t *testing.T) {
 		assert.Contains(t, w.Body.String(), "Failed to fetch corporate")
 	})
 
+	t.Run("synthetic error returns 500", func(t *testing.T) {
+		accounts := mocks.NewMockAccountQuerier(t)
+		stellar := mocks.NewMockStellarServicer(t)
+		tmpl := mocks.NewMockTemplateRenderer(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, errors.New("database error"))
+
+		h, err := New(stellar, accounts, nil, tmpl)
+		require.NoError(t, err)
+
+		req := httptest.NewRequest(http.MethodGet, "/", nil)
+		w := httptest.NewRecorder()
+
+		h.Home(w, req)
+
+		assert.Equal(t, http.StatusInternalServerError, w.Code)
+		assert.Contains(t, w.Body.String(), "Failed to fetch synthetic")
+	})
+
 	t.Run("template render error returns 500", func(t *testing.T) {
 		accounts := mocks.NewMockAccountQuerier(t)
 		stellar := mocks.NewMockStellarServicer(t)

internal/handler/search.go

@@ -60,9 +60,11 @@ type SearchAccountDisplay struct {
 	Name             string
 	MTLAPBalance     float64
 	MTLACBalance     float64
+	MTLAXBalance     float64
 	TotalXLMValue    float64
 	IsPerson         bool
 	IsCorporate      bool
+	IsSynthetic      bool
 	ReputationScore  float64 // Weighted reputation score
 	ReputationGrade  string  // "A", "A-", "B+", etc.
 	ReputationWeight float64 // Total weight of raters
@@ -151,9 +153,11 @@ func (h *Handler) Search(w http.ResponseWriter, r *http.Request) {
 				Name:             row.Name,
 				MTLAPBalance:     row.MTLAPBalance,
 				MTLACBalance:     row.MTLACBalance,
+				MTLAXBalance:     row.MTLAXBalance,
 				TotalXLMValue:    row.TotalXLMValue,
 				IsPerson:         row.MTLAPBalance > 0 && row.MTLAPBalance <= 5,
 				IsCorporate:      row.MTLACBalance > 0 && row.MTLACBalance <= 4,
+				IsSynthetic:      row.MTLAXBalance > 0,
 				ReputationScore:  row.ReputationScore,
 				ReputationGrade:  grade,
 				ReputationWeight: row.ReputationWeight,

internal/repository/account.go

@@ -57,6 +57,7 @@ type CorporateRow struct {
 type SyntheticRow struct {
 	AccountID        string
 	Name             string
+	MTLAXBalance     float64
 	ReputationScore  float64
 	ReputationWeight float64
 }
@@ -181,6 +182,7 @@ func (r *AccountRepository) GetSynthetic(ctx context.Context, limit int, offset
 		Select(
 			"a.account_id",
 			"COALESCE(m.data_value, CONCAT(LEFT(a.account_id, 6), '...', RIGHT(a.account_id, 6))) AS name",
+			"COALESCE(a.mtlax_balance, 0) AS mtlax_balance",
 			"COALESCE(rs.weighted_score, 0) AS reputation_score",
 			"COALESCE(rs.total_weight, 0) AS reputation_weight",
 		).
@@ -205,7 +207,7 @@ func (r *AccountRepository) GetSynthetic(ctx context.Context, limit int, offset
 	var synthetic []SyntheticRow
 	for rows.Next() {
 		var s SyntheticRow
-		if err := rows.Scan(&s.AccountID, &s.Name, &s.ReputationScore, &s.ReputationWeight); err != nil {
+		if err := rows.Scan(&s.AccountID, &s.Name, &s.MTLAXBalance, &s.ReputationScore, &s.ReputationWeight); err != nil {
 			return nil, fmt.Errorf("scan synthetic: %w", err)
 		}
 		synthetic = append(synthetic, s)
@@ -540,6 +542,7 @@ type SearchAccountRow struct {
 	Name             string
 	MTLAPBalance     float64
 	MTLACBalance     float64
+	MTLAXBalance     float64
 	TotalXLMValue    float64
 	ReputationScore  float64 // Weighted reputation score (0 if no ratings)
 	ReputationWeight float64 // Total weight of raters
@@ -579,6 +582,7 @@ func (r *AccountRepository) SearchAccounts(ctx context.Context, query string, ta
 			"COALESCE(m.data_value, CONCAT(LEFT(a.account_id, 6), '...', RIGHT(a.account_id, 6))) AS name",
 			"a.mtlap_balance",
 			"a.mtlac_balance",
+			"COALESCE(a.mtlax_balance, 0) AS mtlax_balance",
 			"a.total_xlm_value",
 			"COALESCE(rs.weighted_score, 0) AS reputation_score",
 			"COALESCE(rs.total_weight, 0) AS reputation_weight",
@@ -649,7 +653,7 @@ func (r *AccountRepository) SearchAccounts(ctx context.Context, query string, ta
 	var accounts []SearchAccountRow
 	for rows.Next() {
 		var acc SearchAccountRow
-		if err := rows.Scan(&acc.AccountID, &acc.Name, &acc.MTLAPBalance, &acc.MTLACBalance, &acc.TotalXLMValue, &acc.ReputationScore, &acc.ReputationWeight); err != nil {
+		if err := rows.Scan(&acc.AccountID, &acc.Name, &acc.MTLAPBalance, &acc.MTLACBalance, &acc.MTLAXBalance, &acc.TotalXLMValue, &acc.ReputationScore, &acc.ReputationWeight); err != nil {
 			return nil, fmt.Errorf("scan search account: %w", err)
 		}
 		accounts = append(accounts, acc)

internal/sync/accounts_test.go

@@ -450,6 +450,42 @@ func TestFindBalance(t *testing.T) {
 	}
 }
 
+func TestGetMTLAXBalance(t *testing.T) {
+	t.Run("no MTLAX trustline returns nil", func(t *testing.T) {
+		data := &AccountData{
+			Balances: []Balance{
+				{AssetCode: "XLM", AssetIssuer: "", Balance: decimal.RequireFromString("100.0000000")},
+				{AssetCode: "MTLAP", AssetIssuer: "GCNVDZIHGX473FEI7IXCUAEXUJ4BGCKEMHF36VYP5EMS7PX2QBLAMTLA", Balance: decimal.RequireFromString("1.0000000")},
+			},
+		}
+		result := getMTLAXBalance(data)
+		assert.Nil(t, result)
+	})
+
+	t.Run("zero MTLAX balance returns pointer to zero", func(t *testing.T) {
+		data := &AccountData{
+			Balances: []Balance{
+				{AssetCode: "MTLAX", AssetIssuer: "GCNVDZIHGX473FEI7IXCUAEXUJ4BGCKEMHF36VYP5EMS7PX2QBLAMTLA", Balance: decimal.Zero},
+			},
+		}
+		result := getMTLAXBalance(data)
+		assert.NotNil(t, result)
+		assert.True(t, decimal.Zero.Equal(*result))
+	})
+
+	t.Run("non-zero MTLAX balance returns pointer to balance", func(t *testing.T) {
+		expected := decimal.RequireFromString("42.5000000")
+		data := &AccountData{
+			Balances: []Balance{
+				{AssetCode: "MTLAX", AssetIssuer: "GCNVDZIHGX473FEI7IXCUAEXUJ4BGCKEMHF36VYP5EMS7PX2QBLAMTLA", Balance: expected},
+			},
+		}
+		result := getMTLAXBalance(data)
+		assert.NotNil(t, result)
+		assert.True(t, expected.Equal(*result))
+	})
+}
+
 func TestFindBalanceEmptySlice(t *testing.T) {
 	result := findBalance([]Balance{}, "XLM", "")
 	assert.True(t, decimal.Zero.Equal(result))

internal/template/templates/home.html

@@ -83,7 +83,7 @@ <h2 class="section-title">Persons</h2>
     </div>
     {{if .HasMorePersons}}
     <div class="pagination">
-        <a href="?persons_offset={{.NextPersonsOffset}}{{if .CorporateOffset}}&corporate_offset={{.CorporateOffset}}{{end}}#persons-section" class="btn">Load More &gt;</a>
+        <a href="?persons_offset={{.NextPersonsOffset}}{{if .SyntheticOffset}}&synthetic_offset={{.SyntheticOffset}}{{end}}{{if .CorporateOffset}}&corporate_offset={{.CorporateOffset}}{{end}}#persons-section" class="btn">Load More &gt;</a>
     </div>
     {{end}}
     {{else}}
@@ -169,7 +169,7 @@ <h2 class="section-title">Corporate</h2>
     </div>
     {{if .HasMoreCorporate}}
     <div class="pagination">
-        <a href="?{{if .PersonsOffset}}persons_offset={{.PersonsOffset}}&{{end}}corporate_offset={{.NextCorporateOffset}}#corporate-section" class="btn">Load More &gt;</a>
+        <a href="?{{if .PersonsOffset}}persons_offset={{.PersonsOffset}}&{{end}}{{if .SyntheticOffset}}synthetic_offset={{.SyntheticOffset}}&{{end}}corporate_offset={{.NextCorporateOffset}}#corporate-section" class="btn">Load More &gt;</a>
     </div>
     {{end}}
     {{else}}

internal/template/templates/search.html

@@ -127,6 +127,7 @@
                     </td>
                     <td>
                         {{if $acc.IsPerson}}<span class="type-badge type-person">[MTLAP]</span>{{end}}
+                        {{if $acc.IsSynthetic}}<span class="type-badge mtlax">[MTLAX]</span>{{end}}
                         {{if $acc.IsCorporate}}<span class="type-badge type-corporate">[MTLAC]</span>{{end}}
                     </td>
                     <td class="cell-num">