func (s *Service) calculateVenuePositions(snapshot DealSnapshot) map[recomma.OrderIdentifier]float64 {
    venuePositions := make(map[venueKey]float64)
    venueIdentifiers := make(map[venueKey]recomma.OrderIdentifier)

    for _, order := range snapshot.Orders {
        key := venueKey{venue: order.Identifier.VenueID, wallet: order.Identifier.Wallet}

        // Store arbitrary identifier (whichever order is processed last)
        if _, exists := venueIdentifiers[key]; !exists {
            venueIdentifiers[key] = order.Identifier  // ⚠️ Arbitrary OrderId
        }

        // Calculate position...
    }

    // Return with arbitrary OrderId in the key
    result := make(map[recomma.OrderIdentifier]float64)
    for key, netQty := range venuePositions {
        result[venueIdentifiers[key]] = netQty  // OrderId is meaningless here
    }
    return result
}

venuePositions := s.calculateVenuePositions(snapshot)
for ident, venueNetQty := range venuePositions {
    key := venueKey{venue: ident.VenueID, wallet: ident.Wallet}  // Only uses venue+wallet
    // ident.OrderId is ignored ✅
}

func (s *Service) calculateVenuePositions(snapshot DealSnapshot) map[venueKey]float64 {
    positions := make(map[venueKey]float64)

    for _, order := range snapshot.Orders {
        key := venueKey{venue: order.Identifier.VenueID, wallet: order.Identifier.Wallet}

        if order.Side == "B" || strings.EqualFold(order.Side, "BUY") {
            positions[key] += order.FilledQty
        } else {
            positions[key] -= order.FilledQty
        }
    }

    return positions
}

// Update ReconcileTakeProfits to use venueKey directly

func (s *Service) calculateVenuePositions(snapshot DealSnapshot) map[recomma.OrderIdentifier]float64 {
    // ...
    for key, netQty := range venuePositions {
        // Use zero OrderId to indicate "not specific to any order"
        ident := recomma.NewOrderIdentifier(
            recomma.VenueID(key.venue),
            key.wallet,
            orderid.OrderId{}, // ✅ Explicit zero value
        )
        result[ident] = netQty
    }
    return result
}

// calculateVenuePositions computes net filled quantity per (venue, wallet) pair.
//
// NOTE: The returned map keys include an OrderIdentifier, but the OrderId field
// is ARBITRARY and should be ignored. Only the VenueID and Wallet fields are
// meaningful for position aggregation. Callers should extract venue+wallet only.
func (s *Service) calculateVenuePositions(snapshot DealSnapshot) map[recomma.OrderIdentifier]float64 {
    // ...
}