commit

Author: bufdev

internal/ibctl/ibctlmerge/ibctlmerge.go

@@ -195,7 +195,15 @@ func Merge(
 		if allTrades[i].GetAccountAlias() != allTrades[j].GetAccountAlias() {
 			return allTrades[i].GetAccountAlias() < allTrades[j].GetAccountAlias()
 		}
-		return allTrades[i].GetSymbol() < allTrades[j].GetSymbol()
+		if allTrades[i].GetSymbol() != allTrades[j].GetSymbol() {
+			return allTrades[i].GetSymbol() < allTrades[j].GetSymbol()
+		}
+		// Side tiebreaker: buys before sells for consistent FIFO lot creation.
+		if allTrades[i].GetSide() != allTrades[j].GetSide() {
+			return allTrades[i].GetSide() < allTrades[j].GetSide()
+		}
+		// Trade ID as final tiebreaker for guaranteed determinism.
+		return allTrades[i].GetTradeId() < allTrades[j].GetTradeId()
 	})
 	return &MergedData{
 		Trades:           allTrades,

internal/ibctl/ibctltaxlot/ibctltaxlot.go

@@ -329,7 +329,24 @@ func ComputeTaxLots(trades []*datav1.Trade) (*TaxLotResult, error) {
 				return dateI < dateJ
 			}
 			// Within the same date, buys (side=1) come before sells (side=2).
-			return trades[i].GetSide() < trades[j].GetSide()
+			if trades[i].GetSide() != trades[j].GetSide() {
+				return trades[i].GetSide() < trades[j].GetSide()
+			}
+			// Price tiebreaker: sort by trade price ascending so FIFO consumes
+			// cheaper lots first when multiple lots open on the same date.
+			priceI := moneypb.MoneyToMicros(trades[i].GetTradePrice())
+			priceJ := moneypb.MoneyToMicros(trades[j].GetTradePrice())
+			if priceI != priceJ {
+				return priceI < priceJ
+			}
+			// Quantity tiebreaker for deterministic ordering of same-price lots.
+			qtyI := mathpb.ToMicros(trades[i].GetQuantity())
+			qtyJ := mathpb.ToMicros(trades[j].GetQuantity())
+			if qtyI != qtyJ {
+				return qtyI < qtyJ
+			}
+			// Final tiebreaker: trade ID for guaranteed determinism.
+			return trades[i].GetTradeId() < trades[j].GetTradeId()
 		})
 	}
 	// Process trades using FIFO within each (account, symbol) group.
@@ -499,6 +516,38 @@ func ComputeTaxLots(trades []*datav1.Trade) (*TaxLotResult, error) {
 		// Final tiebreaker: sort by quantity ascending.
 		return mathpb.ToMicros(result[i].GetQuantity()) < mathpb.ToMicros(result[j].GetQuantity())
 	})
+	// Sort realized matches for deterministic output. Without this sort, the
+	// matches appear in map iteration order (from the keyTrades loop above),
+	// and sort.Slice in downstream consumers can produce different results
+	// for different initial orderings even with a complete comparator.
+	sort.Slice(realizedMatches, func(i, j int) bool {
+		si := FormatDate(realizedMatches[i].SellDate)
+		sj := FormatDate(realizedMatches[j].SellDate)
+		if si != sj {
+			return si < sj
+		}
+		if realizedMatches[i].Symbol != realizedMatches[j].Symbol {
+			return realizedMatches[i].Symbol < realizedMatches[j].Symbol
+		}
+		if realizedMatches[i].AccountAlias != realizedMatches[j].AccountAlias {
+			return realizedMatches[i].AccountAlias < realizedMatches[j].AccountAlias
+		}
+		bi := FormatDate(realizedMatches[i].BuyDate)
+		bj := FormatDate(realizedMatches[j].BuyDate)
+		if bi != bj {
+			return bi < bj
+		}
+		if realizedMatches[i].BuyPriceMicros != realizedMatches[j].BuyPriceMicros {
+			return realizedMatches[i].BuyPriceMicros < realizedMatches[j].BuyPriceMicros
+		}
+		if realizedMatches[i].SellPriceMicros != realizedMatches[j].SellPriceMicros {
+			return realizedMatches[i].SellPriceMicros < realizedMatches[j].SellPriceMicros
+		}
+		if realizedMatches[i].QuantityMicros != realizedMatches[j].QuantityMicros {
+			return realizedMatches[i].QuantityMicros < realizedMatches[j].QuantityMicros
+		}
+		return realizedMatches[i].CurrencyCode < realizedMatches[j].CurrencyCode
+	})
 	return &TaxLotResult{
 		TaxLots:         result,
 		UnmatchedSells:  unmatchedSells,

internal/ibctl/ibctltrades/ibctltrades.go

@@ -13,7 +13,6 @@ package ibctltrades
 
 import (
 	"fmt"
-	"sort"
 
 	datav1 "github.com/bufdev/ibctl/internal/gen/proto/go/ibctl/data/v1"
 	"github.com/bufdev/ibctl/internal/ibctl/ibctlfxrates"
@@ -233,16 +232,12 @@ func GetTradeList(
 		}
 		tradeOverviews = append(tradeOverviews, overview)
 	}
-	// Sort by sale date, then symbol, then account.
-	sort.Slice(tradeOverviews, func(i, j int) bool {
-		if tradeOverviews[i].SaleDate != tradeOverviews[j].SaleDate {
-			return tradeOverviews[i].SaleDate < tradeOverviews[j].SaleDate
-		}
-		if tradeOverviews[i].Symbol != tradeOverviews[j].Symbol {
-			return tradeOverviews[i].Symbol < tradeOverviews[j].Symbol
-		}
-		return tradeOverviews[i].Account < tradeOverviews[j].Account
-	})
+	// No sort needed here — realizedMatches are already sorted deterministically
+	// in ComputeTaxLots by sell date, symbol, account, buy date, buy price,
+	// sell price, and quantity (all using numeric comparison for prices/quantities).
+	// A previous string-based sort here caused non-determinism because string
+	// comparison of decimal numbers (e.g., "24.87" vs "24.8717") disagrees with
+	// numeric comparison, and sort.Slice is input-order-sensitive for ties.
 	return &TradeListResult{
 		Trades:         tradeOverviews,
 		UnmatchedSells: taxLotResult.UnmatchedSells,