diff --git a/package.json b/package.json
index 6cc8052..c9d4cee 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@poap-xyz/poap-family",
-  "version": "1.17.0",
+  "version": "1.17.1",
   "author": {
     "name": "POAP",
     "url": "https://poap.xyz"
diff --git a/src/components/Loading.tsx b/src/components/Loading.tsx
index f890330..a158ed9 100644
--- a/src/components/Loading.tsx
+++ b/src/components/Loading.tsx
@@ -10,6 +10,7 @@ function Loading({
   rate,
   count,
   total,
+  totalFinal = true,
   small = false,
   title,
 }: {
@@ -18,6 +19,7 @@ function Loading({
   rate?: number
   count?: number
   total?: number
+  totalFinal?: boolean
   small?: boolean
   title?: ReactNode
 }) {
@@ -47,7 +49,7 @@ function Loading({
             <>
               <div className="count">{count}</div>
               {typeof total === 'number' && (
-                <div className="total">{total}</div>
+                <div className={clsx('total', { final: totalFinal })}>{total}</div>
               )}
             </>
           )}
diff --git a/src/components/Progress.tsx b/src/components/Progress.tsx
index df2180e..baca8a3 100644
--- a/src/components/Progress.tsx
+++ b/src/components/Progress.tsx
@@ -7,6 +7,7 @@ import 'styles/progress.css'
 function Progress({
   value,
   max,
+  maxFinal = true,
   showValue = false,
   showPercent = false,
   eta,
@@ -14,6 +15,7 @@ function Progress({
 }: {
   value?: number
   max?: number
+  maxFinal?: boolean
   showValue?: boolean
   showPercent?: boolean
   eta?: number
@@ -30,7 +32,11 @@ function Progress({
           value={typeof value === 'number' ? value : undefined}
           max={typeof max === 'number' ? max : undefined}
         />
-        {showValue && <span className="progress-values">{value ?? 0}/{max}</span>}
+        {showValue && (
+          <span className="progress-values">
+            {value ?? 0}/<span className={clsx('max', { final: maxFinal })}>{max}</span>
+          </span>
+        )}
         {showPercent && <span className="progress-percent">
           {hasDetails && (
             <button
diff --git a/src/hooks/useEventInCommon.ts b/src/hooks/useEventInCommon.ts
index bc8b764..99554b6 100644
--- a/src/hooks/useEventInCommon.ts
+++ b/src/hooks/useEventInCommon.ts
@@ -17,7 +17,9 @@ function useEventInCommon(
 ): {
   completedEventInCommon: boolean
   loadingEventInCommon: boolean
-  loadedInCommon: CountProgress | null
+  loadedInCommonState: 'eventIds-a' | 'eventIds-z' | 'owners-a' | 'owners-z' | 'events-a' | 'events-z' | null
+  loadedInCommon: CountProgress & { totalFinal: boolean } | null
+  loadedInCommonEvents: CountProgress | null
   loadedInCommonDownload: DownloadProgress | null
   loadedOwners: number
   ownersErrors: Array<{ address: string; error: Error }>
@@ -29,7 +31,9 @@ function useEventInCommon(
 } {
   const [completed, setCompleted] = useState<boolean>(false)
   const [loading, setLoading] = useState<boolean>(false)
-  const [loadedInCommon, setLoadedInCommon] = useState<CountProgress | null>(null)
+  const [loadedInCommonState, setLoadedInCommonState] = useState<'eventIds-a' | 'eventIds-z' | 'owners-a' | 'owners-z' | 'events-a' | 'events-z' | null>(null)
+  const [loadedInCommon, setLoadedInCommon] = useState<CountProgress & { totalFinal: boolean } | null>(null)
+  const [loadedInCommonEvents, setLoadedInCommonEvents] = useState<CountProgress | null>(null)
   const [loadedProgress, setLoadedProgress] = useState<DownloadProgress | null>(null)
   const [loadedOwners, setLoadedOwners] = useState<number>(0)
   const [errors, setErrors] = useState<Array<{ address: string; error: Error }>>([])
@@ -135,6 +139,7 @@ function useEventInCommon(
 
   const fetchEventInCommon = useCallback(
     () => {
+      const controller = new AbortController()
       const controllers: Record<string, AbortController> = owners.reduce(
         (ctrls, owner) => ({ ...ctrls, [owner]: new AbortController() }),
         {}
@@ -149,21 +154,64 @@ function useEventInCommon(
         setLoadedOwners(0)
         setLoadedInCommon(null)
         setLoadedProgress(null)
+        setLoadedInCommonState(null)
         ;(
           stream
             ? getInCommonEventsWithEvents(
                 eventId,
                 /*refresh*/force,
-                /*onProgress*/(received, total) => {
-                  setLoadedInCommon({
-                    count: received,
-                    total,
-                  })
+                /*abortSignal*/controller.signal,
+                /*onProgress*/(
+                  receivedOwners,
+                  receivedEventIds,
+                  totalInCommon,
+                  receivedEvents,
+                  totalEvents
+                ) => {
+                  if (receivedEventIds) {
+                    setLoadedInCommonState(
+                      (prevState) => prevState == null ? 'eventIds-a' : prevState
+                    )
+                    setLoadedInCommon({
+                      count: receivedOwners ?? 0,
+                      total: receivedEventIds,
+                      totalFinal: receivedEventIds === totalInCommon,
+                    })
+                    if (receivedEventIds === totalInCommon) {
+                      setLoadedInCommonState(
+                        (prevState) => prevState === 'eventIds-a' ? 'eventIds-z' : prevState
+                      )
+                    }
+                  }
+                  if (receivedOwners) {
+                    setLoadedInCommonState(
+                      (prevState) => prevState === 'eventIds-z' ? 'owners-a' : prevState
+                    )
+                    if (receivedOwners === receivedEventIds) {
+                      setLoadedInCommonState(
+                        (prevState) => prevState === 'owners-a' ? 'owners-z' : prevState
+                      )
+                    }
+                  }
+                  if (totalEvents) {
+                    setLoadedInCommonState(
+                      (prevState) => prevState === 'owners-z' ? 'events-a' : prevState
+                    )
+                    setLoadedInCommonEvents({
+                      count: receivedEvents ?? 0,
+                      total: totalEvents,
+                    })
+                    if (receivedEvents === totalEvents) {
+                      setLoadedInCommonState(
+                        (prevState) => prevState === 'events-a' ? 'events-z' : prevState
+                      )
+                    }
+                  }
                 },
               )
             : getInCommonEventsWithProgress(
                 eventId,
-                /*abortSignal*/undefined,
+                /*abortSignal*/controller.signal,
                 /*onProgress*/({ progress, estimated, rate }) => {
                   if (progress != null) {
                     setLoadedProgress({
@@ -179,6 +227,7 @@ function useEventInCommon(
               )
         ).then(
           (result) => {
+            setLoadedInCommonState(null)
             setLoadedInCommon(null)
             setLoadedProgress(null)
             if (!result) {
@@ -203,6 +252,7 @@ function useEventInCommon(
         })
       }
       return () => {
+        controller.abort()
         for (const controller of Object.values(controllers)) {
           controller.abort()
         }
@@ -210,6 +260,7 @@ function useEventInCommon(
         setLoading(false)
         setLoadedInCommon(null)
         setLoadedProgress(null)
+        setLoadedInCommonState(null)
         setLoadedOwners(0)
         setErrors([])
         setInCommon({})
@@ -232,7 +283,9 @@ function useEventInCommon(
   return {
     completedEventInCommon: completed,
     loadingEventInCommon: loading,
+    loadedInCommonState,
     loadedInCommon,
+    loadedInCommonEvents,
     loadedInCommonDownload: loadedProgress,
     loadedOwners,
     ownersErrors: errors,
diff --git a/src/hooks/useEventsInCommon.ts b/src/hooks/useEventsInCommon.ts
index 42fe01d..f1c2745 100644
--- a/src/hooks/useEventsInCommon.ts
+++ b/src/hooks/useEventsInCommon.ts
@@ -20,7 +20,9 @@ function useEventsInCommon(
   completedInCommonEvents: Record<number, boolean>
   loadingInCommonEvents: Record<number, boolean>
   eventsInCommonErrors: Record<number, Record<string, Error>>
-  loadedEventsInCommon: Record<number, CountProgress>
+  loadedEventsInCommonState: Record<number, 'eventIds-a' | 'eventIds-z' | 'owners-a' | 'owners-z' | 'events-a' | 'events-z'>
+  loadedEventsInCommon: Record<number, CountProgress & { totalFinal: boolean }>
+  loadedEventsInCommonEvents: Record<number, CountProgress>
   loadedEventsProgress: Record<number, DownloadProgress>
   loadedEventsOwners: Record<number, number>
   eventsInCommon: Record<number, EventsInCommon>
@@ -30,7 +32,9 @@ function useEventsInCommon(
   const [completed, setCompleted] = useState<Record<number, boolean>>({})
   const [loading, setLoading] = useState<Record<number, boolean>>({})
   const [errors, setErrors] = useState<Record<number, Record<string, Error>>>({})
-  const [loadedInCommon, setLoadedInCommon] = useState<Record<number, CountProgress>>({})
+  const [loadedInCommonState, setLoadedInCommonState] = useState<Record<number, 'eventIds-a' | 'eventIds-z' | 'owners-a' | 'owners-z' | 'events-a' | 'events-z'>>({})
+  const [loadedInCommon, setLoadedInCommon] = useState<Record<number, CountProgress & { totalFinal: boolean }>>({})
+  const [loadedInCommonEvents, setLoadedInCommonEvents] = useState<Record<number, CountProgress>>({})
   const [loadedProgress, setLoadedProgress] = useState<Record<number, DownloadProgress>>({})
   const [loadedOwners, setLoadedOwners] = useState<Record<number, number>>({})
   const [inCommon, setInCommon] = useState<Record<number, EventsInCommon>>({})
@@ -38,6 +42,10 @@ function useEventsInCommon(
   useEffect(
     () => {
       for (const eventId of eventIds) {
+        if (eventsOwners[eventId] == null) {
+          console.error('Missing event owners', { eventId })
+          continue
+        }
         if (
           completed[eventId] &&
           (loadedOwners[eventId] ?? 0) === eventsOwners[eventId].length &&
@@ -144,13 +152,54 @@ function useEventsInCommon(
     })
   }
 
+  function addLoadedInCommonState(
+    eventId: number,
+    state: 'eventIds-a' | 'eventIds-z' | 'owners-a' | 'owners-z' | 'events-a' | 'events-z',
+  ): void {
+    setLoadedInCommonState((prevLoadedInCommonState) => ({
+      ...(prevLoadedInCommonState ?? {}),
+      [eventId]: (prevLoadedInCommonState ?? {})[eventId] == null
+        ? state
+        : (prevLoadedInCommonState ?? {})[eventId],
+    }))
+  }
+
+  function updateLoadedInCommonState(
+    eventId: number,
+    whenPrevState: 'eventIds-a' | 'eventIds-z' | 'owners-a' | 'owners-z' | 'events-a' | 'events-z',
+    state: 'eventIds-a' | 'eventIds-z' | 'owners-a' | 'owners-z' | 'events-a' | 'events-z',
+  ): void {
+    setLoadedInCommonState((prevLoadedInCommonState) => ({
+      ...(prevLoadedInCommonState ?? {}),
+      [eventId]: (prevLoadedInCommonState ?? {})[eventId] === whenPrevState
+        ? state
+        : (prevLoadedInCommonState ?? {})[eventId],
+    }))
+  }
+
+  function removeLoadedInCommonState(eventId: number): void {
+    setLoadedInCommonState((prevLoadedInCommonState) => {
+      if (prevLoadedInCommonState == null) {
+        return {}
+      }
+      const newProgress: Record<number, 'eventIds-a' | 'eventIds-z' | 'owners-a' | 'owners-z' | 'events-a' | 'events-z'> = {}
+      for (const [loadingEventId, progress] of Object.entries(prevLoadedInCommonState)) {
+        if (String(eventId) !== String(loadingEventId)) {
+          newProgress[loadingEventId] = progress
+        }
+      }
+      return newProgress
+    })
+  }
+
   function updateLoadedInCommon(
     eventId: number,
     { count, total }: CountProgress,
+    totalFinal: boolean,
   ) {
     setLoadedInCommon((prevLoadedInCommon) => ({
       ...(prevLoadedInCommon ?? {}),
-      [eventId]: { count, total },
+      [eventId]: { count, total, totalFinal },
     }))
   }
 
@@ -159,7 +208,7 @@ function useEventsInCommon(
       if (prevLoadedInCommon == null) {
         return {}
       }
-      const newProgress: Record<number, CountProgress> = {}
+      const newProgress: Record<number, CountProgress & { totalFinal: boolean }> = {}
       for (const [loadingEventId, progress] of Object.entries(prevLoadedInCommon)) {
         if (String(eventId) !== String(loadingEventId)) {
           newProgress[loadingEventId] = progress
@@ -169,6 +218,31 @@ function useEventsInCommon(
     })
   }
 
+  function updateLoadedInCommonEvents(
+    eventId: number,
+    { count, total }: CountProgress,
+  ) {
+    setLoadedInCommonEvents((prevLoadedInCommonEvents) => ({
+      ...(prevLoadedInCommonEvents ?? {}),
+      [eventId]: { count, total },
+    }))
+  }
+
+  function removeLoadedInCommonEvents(eventId: number): void {
+    setLoadedInCommonEvents((prevLoadedInCommonEvents) => {
+      if (prevLoadedInCommonEvents == null) {
+        return {}
+      }
+      const newProgress: Record<number, CountProgress> = {}
+      for (const [loadingEventId, progress] of Object.entries(prevLoadedInCommonEvents)) {
+        if (String(eventId) !== String(loadingEventId)) {
+          newProgress[loadingEventId] = progress
+        }
+      }
+      return newProgress
+    })
+  }
+
   function addLoadedProgress(eventId: number): void {
     setLoadedProgress((alsoProgress) => ({
       ...alsoProgress,
@@ -417,16 +491,54 @@ function useEventsInCommon(
             result = await getInCommonEventsWithEvents(
               eventId,
               /*refresh*/force,
-              /*onProgress*/(received, total) => {
-                updateLoadedInCommon(eventId, { count: received, total })
+              /*abortSignal*/controller.signal,
+              /*onProgress*/(
+                receivedOwners,
+                receivedEventIds,
+                totalInCommon,
+                receivedEvents,
+                totalEvents
+              ) => {
+                if (receivedEventIds) {
+                  addLoadedInCommonState(eventId, 'eventIds-a')
+                  updateLoadedInCommon(
+                    eventId,
+                    {
+                      count: receivedOwners ?? 0,
+                      total: receivedEventIds,
+                    },
+                    receivedEventIds === totalInCommon
+                  )
+                  if (receivedEventIds === totalInCommon) {
+                    updateLoadedInCommonState(eventId, 'eventIds-a', 'eventIds-z')
+                  }
+                }
+                if (receivedOwners) {
+                  updateLoadedInCommonState(eventId, 'eventIds-z', 'owners-a')
+                  if (receivedOwners === receivedEventIds) {
+                    updateLoadedInCommonState(eventId, 'owners-a', 'owners-z')
+                  }
+                }
+                if (totalEvents) {
+                  updateLoadedInCommonState(eventId, 'owners-z', 'events-a')
+                  updateLoadedInCommonEvents(eventId, {
+                    count: receivedEvents ?? 0,
+                    total: totalEvents,
+                  })
+                  if (receivedEvents === totalEvents) {
+                    updateLoadedInCommonState(eventId, 'events-a', 'events-z')
+                  }
+                }
               },
             )
+            removeLoadedInCommonState(eventId)
             removeLoadedInCommon(eventId)
+            removeLoadedInCommonEvents(eventId)
           } else {
             addLoadedProgress(eventId)
             result = await getInCommonEventsWithProgress(
               eventId,
-              controller.signal,
+              /*abortSignal*/controller.signal,
               /*onProgress*/({ progress, estimated, rate }) => {
                 if (progress != null) {
                   updateLoadedProgress(eventId, { progress, estimated, rate })
@@ -439,7 +551,9 @@ function useEventsInCommon(
             removeLoadedProgress(eventId)
           }
         } catch (err: unknown) {
+          removeLoadedInCommonState(eventId)
           removeLoadedInCommon(eventId)
+          removeLoadedInCommonEvents(eventId)
           removeLoadedProgress(eventId)
           if (!(err instanceof AbortedError)) {
             console.error(err)
@@ -449,7 +563,9 @@ function useEventsInCommon(
           }
           return
         }
+        removeLoadedInCommonState(eventId)
         removeLoadedInCommon(eventId)
+        removeLoadedInCommonEvents(eventId)
         removeLoadedProgress(eventId)
         if (result == null) {
           await processEvent(eventId, addresses, controllers)
@@ -541,7 +657,9 @@ function useEventsInCommon(
     completedInCommonEvents: completed,
     loadingInCommonEvents: loading,
     eventsInCommonErrors: errors,
+    loadedEventsInCommonState: loadedInCommonState,
     loadedEventsInCommon: loadedInCommon,
+    loadedEventsInCommonEvents: loadedInCommonEvents,
     loadedEventsProgress: loadedProgress,
     loadedEventsOwners: loadedOwners,
     eventsInCommon: inCommon,
diff --git a/src/loaders/api.ts b/src/loaders/api.ts
index a2e58b7..76ed829 100644
--- a/src/loaders/api.ts
+++ b/src/loaders/api.ts
@@ -294,42 +294,78 @@ export async function getInCommonEventsWithProgress(
 export async function getInCommonEventsWithEvents(
   eventId: number,
   refresh: boolean = false,
-  onProgress: (received: number, total: number) => void,
+  abortSignal?: AbortSignal,
+  onProgress?: (
+    receivedOwners: number | null,
+    receivedEventIds: number | null,
+    totalInCommon: number | null,
+    receivedEvents: number | null,
+    totalEvents: number | null,
+  ) => void,
   onTs?: (ts: number) => void,
   onEventIds?: (eventIds: number[]) => void,
+  onTotal?: (total: number) => void,
   onInCommon?: (eventId: number, owners: string[]) => void,
+  onEventsTotal?: (eventsTotal: number) => void,
+  onEvents?: (events: Drop[]) => void,
 ): Promise<EventsInCommon | null> {
-  let total: number
-  let received = 0
+  let totalInCommon: number | null = null
+  let totalEvents: number | null = null
+  let receivedEventIds: number | null = null
+  let receivedOwners: number | null = null
+  let receivedEvents: number | null = null
+
   const inCommon: EventsInCommon = {
     events: {},
     inCommon: {},
     ts: null,
   }
-  const inCommonEvents = new EventSource(
+  const inCommonStream = new EventSource(
     `${FAMILY_API_URL}/event/${eventId}/in-common` +
       `/stream${refresh ? '?refresh=true' : ''}`
   )
+
+  if (abortSignal) {
+    abortSignal.addEventListener('abort', () => {
+      inCommonStream.close()
+    })
+  }
+
   return new Promise((resolve, reject) => {
-    inCommonEvents.addEventListener('error', (ev) => {
-      reject(new Error(`Something happen: ${ev}`))
+    inCommonStream.addEventListener('error', (ev) => {
+      inCommonStream.close()
+      reject(new Error(
+        `Connection lost to event '${eventId}' in common streaming`
+      ))
     })
 
-    inCommonEvents.addEventListener('message', (ev) => {
+    inCommonStream.addEventListener('message', (ev) => {
       let data: unknown | undefined
       try {
         data = JSON.parse(ev.data)
       } catch {
-        reject(new Error(`Cannot parse data '${ev.data}'`))
+        reject(new Error(
+          `Cannot parse data '${ev.data}' when streaming ` +
+          `event '${eventId}' in common`
+        ))
         return
       }
       if (!data || typeof data !== 'object') {
-        reject(new Error('Malformed data'))
+        reject(new Error(
+          `Malformed data '${data}' when streaming event '${eventId}' in common`
+        ))
         return
       }
       if ('ts' in data && data.ts && typeof data.ts === 'number') {
         inCommon.ts = data.ts
         onTs?.(data.ts)
+        onProgress?.(
+          receivedOwners,
+          receivedEventIds,
+          totalInCommon,
+          receivedEvents,
+          totalEvents
+        )
       }
       if (
         'eventIds' in data &&
@@ -339,11 +375,39 @@ export async function getInCommonEventsWithEvents(
           (eventId) => eventId && typeof eventId === 'number'
         )
       ) {
-        total = data.eventIds.length
+        if (receivedEventIds == null) {
+          receivedEventIds = data.eventIds.length
+        } else {
+          receivedEventIds += data.eventIds.length
+        }
         for (const eventId of data.eventIds) {
           inCommon.inCommon[eventId] = []
         }
         onEventIds?.(data.eventIds)
+        onProgress?.(
+          receivedOwners,
+          receivedEventIds,
+          totalInCommon,
+          receivedEvents,
+          totalEvents
+        )
+      }
+      if ('total' in data && data.total && typeof data.total === 'number') {
+        if (totalInCommon != null) {
+          reject(new Error(
+            `Received total (with value ${data.total} was ${totalInCommon}) ` +
+            `two times when streaming event '${eventId}' in common`
+          ))
+        }
+        totalInCommon = data.total
+        onTotal?.(totalInCommon)
+        onProgress?.(
+          receivedOwners,
+          receivedEventIds,
+          totalInCommon,
+          receivedEvents,
+          totalEvents
+        )
       }
       if (
         'eventId' in data &&
@@ -356,31 +420,90 @@ export async function getInCommonEventsWithEvents(
           (owner) => owner && typeof owner === 'string'
         )
       ) {
-        received++
+        if (receivedOwners == null) {
+          receivedOwners = 1
+        } else {
+          receivedOwners++
+        }
+        if (!receivedEventIds || !totalInCommon) {
+          reject(new Error(
+            `Received the first in common event before the total ` +
+            `when streaming event '${eventId}' in common`
+          ))
+        }
         inCommon.inCommon[data.eventId] = data.owners
         onInCommon?.(data.eventId, data.owners)
-        if (total) {
-          onProgress(received, total)
-        }
+        onProgress?.(
+          receivedOwners,
+          receivedEventIds,
+          totalInCommon,
+          receivedEvents,
+          totalEvents
+        )
       }
       if (
         'events' in data &&
         data.events &&
-        typeof data.events === 'object'
-      ) {
-        inCommon.events = Object.fromEntries(
-          Object.entries(data.events).map(
-            ([eventIdRaw, eventData]) => [
-              eventIdRaw,
-              parseDrop(eventData, /*includeDescription*/false),
-            ]
+        Array.isArray(data.events) &&
+        data.events.every(
+          (event) => (
+            event && typeof event === 'object' &&
+            'id' in event && event.id && typeof event.id === 'number'
           )
         )
+      ) {
+        const drops = data.events.map(
+          (event) => parseDrop(event, /*includeDescription*/false)
+        )
+        if (receivedEvents == null) {
+          receivedEvents = drops.length
+        } else {
+          receivedEvents += drops.length
+        }
+        for (const drop of drops) {
+          inCommon.events[drop.id] = drop
+        }
+        onEvents?.(drops)
+        onProgress?.(
+          receivedOwners,
+          receivedEventIds,
+          totalInCommon,
+          receivedEvents,
+          totalEvents
+        )
+      }
+      if (
+        'eventsTotal' in data &&
+        data.eventsTotal &&
+        typeof data.eventsTotal === 'number'
+      ) {
+        if (totalEvents != null) {
+          reject(new Error(
+            `Received events total (with value ${data.eventsTotal} was ${totalEvents}) ` +
+            `two times when streaming event '${eventId}' in common`
+          ))
+        }
+        totalEvents = data.eventsTotal
+        onEventsTotal?.(data.eventsTotal)
+        onProgress?.(
+          receivedOwners,
+          receivedEventIds,
+          totalInCommon,
+          receivedEvents,
+          totalEvents
+        )
       }
       if (
         inCommon.ts != null &&
-        received === total &&
+        totalInCommon != null &&
+        receivedEventIds != null &&
+        receivedOwners != null &&
+        receivedOwners === receivedEventIds &&
+        receivedEventIds === totalInCommon &&
         Object.values(inCommon.inCommon).every((owners) => owners.length > 0) &&
+        receivedEvents != null &&
+        totalEvents != null &&
+        receivedEvents === totalEvents &&
         Object.keys(inCommon.events).length > 0
       ) {
         resolve(inCommon)
diff --git a/src/models/compass.ts b/src/models/compass.ts
index f4c7768..a473245 100644
--- a/src/models/compass.ts
+++ b/src/models/compass.ts
@@ -1,4 +1,4 @@
 export const COMPASS_URL = process.env.REACT_APP_COMPASS_URL ?? 'https://public.compass.poap.tech/v1/graphql'
 export const COMPASS_KEY = process.env.REACT_APP_COMPASS_KEY
 
-export const DEFAULT_COMPASS_LIMIT = 1000
+export const DEFAULT_COMPASS_LIMIT = 100
diff --git a/src/pages/Event.tsx b/src/pages/Event.tsx
index 110dd23..621fc2e 100644
--- a/src/pages/Event.tsx
+++ b/src/pages/Event.tsx
@@ -47,6 +47,7 @@ function Event() {
     completedEventInCommon,
     loadingEventInCommon,
     loadedInCommon,
+    loadedInCommonEvents,
     loadedInCommonDownload,
     loadedOwners,
     ownersErrors,
@@ -181,24 +182,34 @@ function Event() {
             {loadedOwners > 0
               ? <Loading count={loadedOwners} total={owners.length} />
               : (
-                loadedInCommon != null
+                loadedInCommonEvents != null
                   ? (
                     <Loading
-                      count={loadedInCommon.count}
-                      total={loadedInCommon.total}
+                      count={loadedInCommonEvents.count}
+                      total={loadedInCommonEvents.total}
                     />
                   )
                   : (
-                    loadedInCommonDownload != null
-                      ? (
+                      loadedInCommon != null
+                        ? (
                           <Loading
-                            progress={loadedInCommonDownload.progress}
-                            eta={loadedInCommonDownload.estimated}
-                            rate={loadedInCommonDownload.rate}
+                            count={loadedInCommon.count}
+                            total={loadedInCommon.total}
+                            totalFinal={loadedInCommon.totalFinal}
                           />
                         )
-                      : <Loading />
-                  )
+                        : (
+                          loadedInCommonDownload != null
+                            ? (
+                                <Loading
+                                  progress={loadedInCommonDownload.progress}
+                                  eta={loadedInCommonDownload.estimated}
+                                  rate={loadedInCommonDownload.rate}
+                                />
+                              )
+                            : <Loading />
+                        )
+                    )
               )
             }
             <AddressErrorList errors={ownersErrors} onRetry={retryAddress} />
diff --git a/src/pages/Events.tsx b/src/pages/Events.tsx
index 797b7cd..9f09a4b 100644
--- a/src/pages/Events.tsx
+++ b/src/pages/Events.tsx
@@ -79,6 +79,7 @@ function Events() {
     loadingInCommonEvents,
     eventsInCommonErrors,
     loadedEventsInCommon,
+    loadedEventsInCommonEvents,
     loadedEventsProgress,
     loadedEventsOwners,
     eventsInCommon,
@@ -372,6 +373,7 @@ function Events() {
                       {(
                         loadingInCommonEvents[event.id] != null &&
                         loadedEventsInCommon[event.id] == null &&
+                        loadedEventsInCommonEvents[event.id] == null &&
                         loadedEventsProgress[event.id] == null &&
                         loadedEventsOwners[event.id] != null &&
                         eventsOwners[event.id] != null
@@ -384,16 +386,30 @@ function Events() {
                       )}
                       {(
                         loadedEventsInCommon[event.id] != null &&
+                        loadedEventsInCommonEvents[event.id] == null &&
                         loadedEventsProgress[event.id] == null
                        ) && (
                         <Progress
                           value={loadedEventsInCommon[event.id].count}
                           max={loadedEventsInCommon[event.id].total}
-                          showValue={loadedEventsInCommon[event.id].count > 0}
+                          maxFinal={loadedEventsInCommon[event.id].totalFinal}
+                          showValue={loadedEventsInCommon[event.id].total > 0}
+                        />
+                      )}
+                      {(
+                        loadedEventsInCommon[event.id] != null &&
+                        loadedEventsInCommonEvents[event.id] != null &&
+                        loadedEventsProgress[event.id] == null
+                       ) && (
+                        <Progress
+                          value={loadedEventsInCommonEvents[event.id].count}
+                          max={loadedEventsInCommonEvents[event.id].total}
+                          showValue={loadedEventsInCommonEvents[event.id].total > 0}
                         />
                       )}
                       {(
                         loadedEventsInCommon[event.id] == null &&
+                        loadedEventsInCommonEvents[event.id] == null &&
                         loadedEventsProgress[event.id] != null
                        ) && (
                         <Progress
diff --git a/src/styles/loading.css b/src/styles/loading.css
index 0cfec2e..5b0bd5b 100644
--- a/src/styles/loading.css
+++ b/src/styles/loading.css
@@ -40,6 +40,10 @@
   text-decoration: overline;
 }
 
+.loading .total.final {
+  font-weight: 700;
+}
+
 .loading .details {
   display: block;
   position: absolute;
diff --git a/src/styles/progress.css b/src/styles/progress.css
index d095bf6..d666a1d 100644
--- a/src/styles/progress.css
+++ b/src/styles/progress.css
@@ -42,6 +42,10 @@
   margin-bottom: .25rem;
 }
 
+.progress .progress-values .max.final {
+  font-weight: 700;
+}
+
 .progress .show-details {
   appearance: none;
   outline: none;