diff --git a/client/src/App.tsx b/client/src/App.tsx
index 3dd68dcd9..ad945072a 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -1,6 +1,7 @@
 import "./index.css";
 import { Toaster } from "./ui/components/Toaster";
 import { TransactionNotification } from "./ui/components/TxEmit";
+import { WorldLoading } from "./ui/components/WorldLoading";
 import { World } from "./ui/layouts/World";
 
 function App({ backgroundImage }: { backgroundImage: string }) {
@@ -9,6 +10,7 @@ function App({ backgroundImage }: { backgroundImage: string }) {
       <Toaster />
       <TransactionNotification />
       <World backgroundImage={backgroundImage} />
+      <WorldLoading />
     </>
   );
 }
diff --git a/client/src/dojo/debouncedQueries.ts b/client/src/dojo/debouncedQueries.ts
new file mode 100644
index 000000000..58558184e
--- /dev/null
+++ b/client/src/dojo/debouncedQueries.ts
@@ -0,0 +1,163 @@
+import { Component, Metadata, Schema } from "@dojoengine/recs";
+import { ToriiClient } from "@dojoengine/torii-client";
+import debounce from "lodash/debounce";
+import {
+  addArrivalsSubscription,
+  addHyperstructureSubscription,
+  addMarketSubscription,
+  addToSubscription,
+  addToSubscriptionOneKeyModelbyRealmEntityId,
+  addToSubscriptionTwoKeyModelbyRealmEntityId,
+  syncPosition,
+} from "./queries";
+
+// Queue class to manage requests
+class RequestQueue {
+  private queue: Array<() => Promise<void>> = [];
+  private processing = false;
+  private batchSize = 3; // Number of concurrent requests
+  private batchDelayMs = 100; // Delay between batches
+
+  async add(request: () => Promise<void>, onComplete?: () => void) {
+    this.queue.push(async () => {
+      await request();
+      onComplete?.(); // Call onComplete after the request is processed
+    });
+    if (!this.processing) {
+      this.processing = true;
+      this.processQueue();
+    }
+  }
+
+  private async processQueue() {
+    while (this.queue.length > 0) {
+      const batch = this.queue.splice(0, this.batchSize);
+
+      try {
+        await Promise.all(batch.map((request) => request()));
+      } catch (error) {
+        console.error("Error processing request batch:", error);
+      }
+
+      if (this.queue.length > 0) {
+        // Add delay between batches to prevent overwhelming the server
+        await new Promise((resolve) => setTimeout(resolve, this.batchDelayMs));
+      }
+    }
+    this.processing = false;
+  }
+
+  clear() {
+    this.queue = [];
+  }
+}
+
+// Create separate queues for different types of requests
+const positionQueue = new RequestQueue();
+const subscriptionQueue = new RequestQueue();
+const marketQueue = new RequestQueue();
+const hyperstructureQueue = new RequestQueue();
+// Debounced functions that add to queues
+export const debouncedSyncPosition = debounce(
+  async <S extends Schema>(
+    client: ToriiClient,
+    components: Component<S, Metadata, undefined>[],
+    entityID: string,
+    onComplete?: () => void,
+  ) => {
+    await positionQueue.add(() => syncPosition(client, components, entityID), onComplete);
+  },
+  100,
+  { leading: true }, // Add leading: true to execute immediately on first call
+);
+
+export const debouncedAddToSubscriptionTwoKey = debounce(
+  async <S extends Schema>(
+    client: ToriiClient,
+    components: Component<S, Metadata, undefined>[],
+    entityID: string[],
+    onComplete?: () => void,
+  ) => {
+    await subscriptionQueue.add(
+      () => addToSubscriptionTwoKeyModelbyRealmEntityId(client, components, entityID),
+      onComplete,
+    );
+  },
+  250,
+  { leading: true },
+);
+
+export const debouncedAddToSubscriptionOneKey = debounce(
+  async <S extends Schema>(
+    client: ToriiClient,
+    components: Component<S, Metadata, undefined>[],
+    entityID: string[],
+    onComplete?: () => void,
+  ) => {
+    await subscriptionQueue.add(
+      () => addToSubscriptionOneKeyModelbyRealmEntityId(client, components, entityID),
+      onComplete,
+    );
+  },
+  250,
+  { leading: true },
+);
+
+export const debounceAddResourceArrivals = debounce(
+  async <S extends Schema>(
+    client: ToriiClient,
+    components: Component<S, Metadata, undefined>[],
+    entityID: number[],
+    onComplete?: () => void,
+  ) => {
+    await subscriptionQueue.add(() => addArrivalsSubscription(client, components, entityID), onComplete);
+  },
+  250,
+  { leading: true },
+);
+
+export const debouncedAddToSubscription = debounce(
+  async <S extends Schema>(
+    client: ToriiClient,
+    components: Component<S, Metadata, undefined>[],
+    entityID: string[],
+    position?: { x: number; y: number }[],
+    onComplete?: () => void,
+  ) => {
+    await subscriptionQueue.add(() => addToSubscription(client, components, entityID, position), onComplete);
+  },
+  250,
+  { leading: true },
+);
+
+export const debouncedAddMarketSubscription = debounce(
+  async <S extends Schema>(
+    client: ToriiClient,
+    components: Component<S, Metadata, undefined>[],
+    onComplete?: () => void,
+  ) => {
+    await marketQueue.add(() => addMarketSubscription(client, components), onComplete);
+  },
+  500,
+  { leading: true },
+);
+
+export const debouncedAddHyperstructureSubscription = debounce(
+  async <S extends Schema>(
+    client: ToriiClient,
+    components: Component<S, Metadata, undefined>[],
+    onComplete?: () => void,
+  ) => {
+    await hyperstructureQueue.add(() => addHyperstructureSubscription(client, components), onComplete);
+  },
+  500,
+  { leading: true },
+);
+
+// Utility function to clear all queues if needed
+export const clearAllQueues = () => {
+  positionQueue.clear();
+  subscriptionQueue.clear();
+  marketQueue.clear();
+  hyperstructureQueue.clear();
+};
diff --git a/client/src/dojo/queries.ts b/client/src/dojo/queries.ts
index c1620c90e..20f2e334d 100644
--- a/client/src/dojo/queries.ts
+++ b/client/src/dojo/queries.ts
@@ -25,7 +25,7 @@ export const syncPosition = async <S extends Schema>(
     components,
     [],
     [],
-    30_000,
+    5_000,
   );
 };
 
@@ -53,7 +53,7 @@ export const addToSubscriptionTwoKeyModelbyRealmEntityId = async <S extends Sche
     components,
     [],
     [],
-    30_000,
+    5_000,
   );
 };
 
@@ -81,7 +81,7 @@ export const addToSubscriptionOneKeyModelbyRealmEntityId = async <S extends Sche
     components,
     [],
     [],
-    30_000,
+    5_000,
   );
 };
 
@@ -122,7 +122,7 @@ export const addToSubscription = async <S extends Schema>(
     components as any,
     [],
     [],
-    30_000,
+    5_000,
   );
   const end = performance.now();
   console.log("AddToSubscriptionEnd", end - start);
@@ -136,10 +136,11 @@ export const addMarketSubscription = async <S extends Schema>(
   await getEntities(
     client,
     {
-      Keys: {
-        keys: [undefined, undefined],
-        pattern_matching: "FixedLen",
-        models: ["s0_eternum-DetachedResource"],
+      Member: {
+        model: "s0_eternum-DetachedResource",
+        member: "resource_amount",
+        operator: "Gt",
+        value: { Primitive: { U128: "0" } },
       },
     },
     components,
@@ -151,3 +152,110 @@ export const addMarketSubscription = async <S extends Schema>(
   const end = performance.now();
   console.log("MarketEnd", end - start);
 };
+
+export const addHyperstructureSubscription = async <S extends Schema>(
+  client: ToriiClient,
+  components: Component<S, Metadata, undefined>[],
+) => {
+  const start = performance.now();
+  await getEntities(
+    client,
+    {
+      Composite: {
+        operator: "Or",
+        clauses: [
+          {
+            Keys: {
+              keys: [undefined, undefined],
+              pattern_matching: "FixedLen",
+              models: ["s0_eternum-Epoch", "s0_eternum-Progress"],
+            },
+          },
+          {
+            Keys: {
+              keys: [undefined, undefined, undefined],
+              pattern_matching: "FixedLen",
+              models: ["s0_eternum-Contribution"],
+            },
+          },
+        ],
+      },
+    },
+    components as any,
+    [],
+    [],
+    40_000,
+    false,
+  );
+  const end = performance.now();
+  console.log("HyperstructureEnd", end - start);
+};
+
+export const addArrivalsSubscription = async <S extends Schema>(
+  client: ToriiClient,
+  components: Component<S, Metadata, undefined>[],
+  entityIds: number[],
+) => {
+  const start = performance.now();
+  console.log("ArrivalsEnd: starting resource arrivals");
+  await getEntities(
+    client,
+    // todo: waiting on ghlim to check issue with this query
+    // {
+    //   Composite: {
+    //     operator: "And",
+    //     clauses: [
+    //       {
+    //         Composite: {
+    //           operator: "Or",
+    //           clauses: entityIds.map((id) => ({
+    //             Member: {
+    //               model: "s0_eternum-EntityOwner",
+    //               member: "entity_owner_id",
+    //               operator: "Eq",
+    //               value: { Primitive: { U32: id } },
+    //             },
+    //           })),
+    //         },
+    //       },
+    //       {
+    //         Member: {
+    //           model: "s0_eternum-OwnedResourcesTracker",
+    //           member: "resource_types",
+    //           operator: "Neq",
+    //           value: { Primitive: { U256: "0" } },
+    //         },
+    //       },
+    //     ],
+    //   },
+    // },
+    {
+      Composite: {
+        operator: "Or",
+        clauses: entityIds.map((id) => ({
+          Member: {
+            model: "s0_eternum-EntityOwner",
+            member: "entity_owner_id",
+            operator: "Eq",
+            value: { Primitive: { U32: id } },
+          },
+        })),
+      },
+    },
+
+    components,
+    [],
+    [
+      "s0_eternum-Army",
+      "s0_eternum-Position",
+      "s0_eternum-EntityOwner",
+      "s0_eternum-Weight",
+      "s0_eternum-OwnedResourcesTracker",
+      "s0_eternum-ArrivalTime",
+    ],
+    1000,
+    false,
+  );
+  const end = performance.now();
+  console.log("ArrivalsEnd", end - start);
+};
diff --git a/client/src/dojo/setup.ts b/client/src/dojo/setup.ts
index 29acc548d..25d8fbf31 100644
--- a/client/src/dojo/setup.ts
+++ b/client/src/dojo/setup.ts
@@ -1,25 +1,83 @@
+import { AppStore } from "@/hooks/store/useUIStore";
+import { LoadingStateKey } from "@/hooks/store/useWorldLoading";
 import {
   BUILDING_CATEGORY_POPULATION_CONFIG_ID,
   HYPERSTRUCTURE_CONFIG_ID,
   WORLD_CONFIG_ID,
 } from "@bibliothecadao/eternum";
 import { DojoConfig } from "@dojoengine/core";
-import { getEntities, getEvents } from "@dojoengine/state";
-import { Clause } from "@dojoengine/torii-client";
+import { Component, Metadata, Schema } from "@dojoengine/recs";
+import { getEntities, getEvents, setEntities } from "@dojoengine/state";
+import { Clause, EntityKeysClause, ToriiClient } from "@dojoengine/torii-client";
+import { debounce } from "lodash";
 import { createClientComponents } from "./createClientComponents";
 import { createSystemCalls } from "./createSystemCalls";
 import { ClientConfigManager } from "./modelManager/ConfigManager";
 import { setupNetwork } from "./setupNetwork";
-import { setupWorker } from "./worker";
 
 export type SetupResult = Awaited<ReturnType<typeof setup>>;
 
 export const configManager = ClientConfigManager.instance();
 
-export async function setup({ ...config }: DojoConfig) {
+export const syncEntitiesDebounced = async <S extends Schema>(
+  client: ToriiClient,
+  components: Component<S, Metadata, undefined>[],
+  entityKeyClause: EntityKeysClause[],
+  logging: boolean = true,
+  historical: boolean = false,
+) => {
+  if (logging) console.log("Starting syncEntities");
+
+  let entityBatch: Record<string, any> = {};
+
+  const debouncedSetEntities = debounce(() => {
+    if (Object.keys(entityBatch).length > 0) {
+      // console.log("Applying batch update", entityBatch);
+      setEntities(entityBatch, components, logging);
+      entityBatch = {}; // Clear the batch after applying
+    }
+  }, 200); // Increased debounce time to 1 second for larger batches
+
+  // Handle entity updates
+  const entitySub = await client.onEntityUpdated(entityKeyClause, (fetchedEntities: any, data: any) => {
+    if (logging) console.log("Entity updated", fetchedEntities);
+    // Merge new data with existing data for this entity
+    entityBatch[fetchedEntities] = {
+      ...entityBatch[fetchedEntities],
+      ...data,
+    };
+    debouncedSetEntities();
+  });
+
+  // Handle event message updates
+  const eventSub = await client.onEventMessageUpdated(
+    entityKeyClause,
+    historical,
+    (fetchedEntities: any, data: any) => {
+      if (logging) console.log("Event message updated", fetchedEntities);
+      // Merge new data with existing data for this entity
+      entityBatch[fetchedEntities] = {
+        ...entityBatch[fetchedEntities],
+        ...data,
+      };
+      debouncedSetEntities();
+    },
+  );
+
+  // Return combined subscription that can cancel both
+  return {
+    cancel: () => {
+      entitySub.cancel();
+      eventSub.cancel();
+    },
+  };
+};
+
+export async function setup(config: DojoConfig & { state: AppStore }) {
   const network = await setupNetwork(config);
   const components = createClientComponents(network);
   const systemCalls = createSystemCalls(network);
+  const setLoading = config.state.setLoading;
 
   const configClauses: Clause[] = [
     {
@@ -52,20 +110,44 @@ export async function setup({ ...config }: DojoConfig) {
     },
     {
       Keys: {
-        keys: [HYPERSTRUCTURE_CONFIG_ID.toString(), undefined],
+        keys: [HYPERSTRUCTURE_CONFIG_ID.toString()],
         pattern_matching: "VariableLen",
         models: [],
       },
     },
   ];
 
-  await getEntities(
-    network.toriiClient,
-    { Composite: { operator: "Or", clauses: configClauses } },
-    network.contractComponents as any,
-  );
+  setLoading(LoadingStateKey.Config, true);
+  try {
+    await Promise.all([
+      getEntities(
+        network.toriiClient,
+        { Composite: { operator: "Or", clauses: configClauses } },
+        network.contractComponents as any,
+      ),
+      getEntities(
+        network.toriiClient,
+        {
+          Keys: {
+            keys: [undefined, undefined],
+            pattern_matching: "FixedLen",
+            models: ["s0_eternum-CapacityConfigCategory", "s0_eternum-ResourceCost"],
+          },
+        },
+        network.contractComponents as any,
+        [],
+        [],
+        40_000,
+        false,
+      ),
+    ]);
+  } finally {
+    setLoading(LoadingStateKey.Config, false);
+  }
 
   // fetch all existing entities from torii
+
+  setLoading(LoadingStateKey.SingleKey, true);
   await getEntities(
     network.toriiClient,
     {
@@ -82,10 +164,9 @@ export async function setup({ ...config }: DojoConfig) {
           "s0_eternum-BankConfig",
           "s0_eternum-Bank",
           "s0_eternum-Trade",
-          "s0_eternum-Army",
           "s0_eternum-Structure",
           "s0_eternum-Battle",
-          "s0_eternum-EntityOwner",
+          "s0_eternum-Guild",
         ],
       },
     },
@@ -94,38 +175,15 @@ export async function setup({ ...config }: DojoConfig) {
     [],
     40_000,
     false,
-  );
-
-  await getEntities(
-    network.toriiClient,
-    {
-      Keys: {
-        keys: [undefined, undefined],
-        pattern_matching: "FixedLen",
-        models: ["s0_eternum-CapacityConfigCategory", "s0_eternum-ResourceCost"],
-      },
-    },
-    network.contractComponents as any,
-    [],
-    [],
-    40_000,
-    false,
-  );
+  ).finally(() => {
+    setLoading(LoadingStateKey.SingleKey, false);
+  });
 
-  const sync = await setupWorker(
-    {
-      rpcUrl: config.rpcUrl,
-      toriiUrl: config.toriiUrl,
-      relayUrl: config.relayUrl,
-      worldAddress: config.manifest.world.address || "",
-    },
-    network.contractComponents as any,
-    [],
-    false,
-  );
+  const sync = await syncEntitiesDebounced(network.toriiClient, network.contractComponents as any, [], false);
 
   configManager.setDojo(components);
 
+  setLoading(LoadingStateKey.Events, true);
   const eventSync = getEvents(
     network.toriiClient,
     network.contractComponents.events as any,
@@ -153,7 +211,9 @@ export async function setup({ ...config }: DojoConfig) {
     },
     false,
     false,
-  );
+  ).finally(() => {
+    setLoading(LoadingStateKey.Events, false);
+  });
 
   return {
     network,
diff --git a/client/src/hooks/helpers/use-resource-arrivals.tsx b/client/src/hooks/helpers/use-resource-arrivals.tsx
index ef7af8933..4530c7223 100644
--- a/client/src/hooks/helpers/use-resource-arrivals.tsx
+++ b/client/src/hooks/helpers/use-resource-arrivals.tsx
@@ -1,20 +1,14 @@
 import { ContractAddress, ID, Position } from "@bibliothecadao/eternum";
 import { useEntityQuery } from "@dojoengine/react";
-import {
-  Entity,
-  Has,
-  HasValue,
-  NotValue,
-  defineQuery,
-  getComponentValue,
-  isComponentUpdate,
-  runQuery,
-} from "@dojoengine/recs";
+import { Entity, Has, HasValue, NotValue, defineQuery, getComponentValue, isComponentUpdate } from "@dojoengine/recs";
 import { getEntityIdFromKeys } from "@dojoengine/utils";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { useDojo } from "../context/DojoContext";
 import useNextBlockTimestamp from "../useNextBlockTimestamp";
 
+const DONKEY_RESOURCE_TRACKER = 452312848583266388373324160190187140051835877600158453279131187530910662656n;
+const LORDS_RESOURCE_TRACKER = 7237005577332262213973186563042994240829374041602535252466099000494570602496n;
+
 export type ArrivalInfo = {
   entityId: ID;
   recipientEntityId: ID;
@@ -23,96 +17,90 @@ export type ArrivalInfo = {
   isOwner: boolean;
   hasResources: boolean;
   isHome: boolean;
-  // resources: Resource[];
+};
+
+const getCurrentDonkeyWeightMinimum = () => {
+  return Number(localStorage.getItem("WEIGHT_MINIMUM") || 0) * 1000;
 };
 
 const usePlayerArrivals = () => {
   const {
     account: { account },
     setup: {
-      components: { Position, Owner, EntityOwner, OwnedResourcesTracker, ArrivalTime, Weight, Resource, Structure },
+      components: { Position, Owner, EntityOwner, OwnedResourcesTracker, ArrivalTime, Weight, Structure },
     },
   } = useDojo();
 
+  const minWeight = getCurrentDonkeyWeightMinimum();
+
   const playerStructures = useEntityQuery([
     Has(Structure),
     HasValue(Owner, { address: ContractAddress(account.address) }),
   ]);
 
-  const [playerStructurePositions, setPlayerStructurePositions] = useState<(Position & { entityId: ID })[]>([]);
-
-  useEffect(() => {
-    const positions = playerStructures.map((entityId) => {
+  const playerStructurePositions = useMemo(() => {
+    return playerStructures.map((entityId) => {
       const position = getComponentValue(Position, entityId);
       return { x: position?.x ?? 0, y: position?.y ?? 0, entityId: position?.entity_id || 0 };
     });
-    setPlayerStructurePositions(positions);
   }, [playerStructures, Position]);
 
   const [entitiesWithInventory, setEntitiesWithInventory] = useState<ArrivalInfo[]>([]);
 
-  const queryFragments = [
-    Has(Weight),
-    Has(ArrivalTime),
-    Has(EntityOwner),
-    NotValue(OwnedResourcesTracker, { resource_types: 0n }),
-  ];
-
-  const getArrivalsWithResourceOnPosition = useCallback((positions: Position[]) => {
-    const arrivals = positions.flatMap((position) => {
-      return Array.from(runQuery([HasValue(Position, { x: position.x, y: position.y }), ...queryFragments]));
-    });
-    return arrivals;
-  }, []);
+  const hasMinWeight = useCallback(
+    (entity: Entity) => {
+      const weight = getComponentValue(Weight, entity);
+      return !!(weight?.value && Number(weight.value) >= minWeight);
+    },
+    [minWeight],
+  );
 
   const createArrivalInfo = useCallback(
     (id: Entity): ArrivalInfo | undefined => {
+      // Get required component values
       const position = getComponentValue(Position, id);
-      if (!position) return undefined;
-
       const arrivalTime = getComponentValue(ArrivalTime, id);
-      if (!arrivalTime) return undefined;
-
+      const ownedResourceTracker = getComponentValue(OwnedResourcesTracker, id);
       const entityOwner = getComponentValue(EntityOwner, id);
-      const ownerEntityId = getEntityIdFromKeys([BigInt(entityOwner?.entity_owner_id || 0)]);
-      const owner = getComponentValue(Owner, ownerEntityId);
 
-      if (owner?.address !== ContractAddress(account.address)) {
-        return undefined;
-      }
+      // Return early if missing required components
+      if (!position || !arrivalTime) return undefined;
 
-      const ownedResourceTracker = getComponentValue(OwnedResourcesTracker, id);
+      // Check if entity has special resource types that don't need weight check
+      const hasSpecialResources =
+        ownedResourceTracker?.resource_types === DONKEY_RESOURCE_TRACKER ||
+        ownedResourceTracker?.resource_types === LORDS_RESOURCE_TRACKER;
 
-      const hasResources = !!ownedResourceTracker && ownedResourceTracker.resource_types !== 0n;
+      // Determine if entity meets weight requirements
+      const meetsWeightRequirement = hasSpecialResources || hasMinWeight(id);
 
+      // Get owner information
+      const ownerEntityId = getEntityIdFromKeys([BigInt(entityOwner?.entity_owner_id || 0)]);
+      const owner = getComponentValue(Owner, ownerEntityId);
+      const isOwner = owner?.address === ContractAddress(account.address);
+
+      // Check if entity has resources
+      const hasResources =
+        meetsWeightRequirement && !!ownedResourceTracker && ownedResourceTracker.resource_types !== 0n;
+
+      // Find matching player structure at position
       const playerStructurePosition = playerStructurePositions.find(
         (structurePosition) => structurePosition.x === position.x && structurePosition.y === position.y,
       );
 
-      const isHome = !!playerStructurePosition;
-
       return {
         entityId: position.entity_id,
         recipientEntityId: playerStructurePosition?.entityId || 0,
         arrivesAt: arrivalTime.arrives_at,
-        isOwner: true,
+        isOwner,
         position: { x: position.x, y: position.y },
         hasResources,
-        isHome,
+        isHome: !!playerStructurePosition,
       };
     },
     [account, playerStructurePositions],
   );
 
-  // initial load
-  useEffect(() => {
-    const arrivals = getArrivalsWithResourceOnPosition(playerStructurePositions)
-      .map(createArrivalInfo)
-      .filter((arrival): arrival is ArrivalInfo => arrival !== undefined)
-      .filter((arrival) => arrival.hasResources);
-    setEntitiesWithInventory(arrivals);
-  }, [playerStructurePositions, getArrivalsWithResourceOnPosition, createArrivalInfo]);
-
   const isMine = useCallback(
     (entity: Entity) => {
       const entityOwner = getComponentValue(EntityOwner, entity);
@@ -123,12 +111,21 @@ const usePlayerArrivals = () => {
   );
 
   useEffect(() => {
-    const query = defineQuery([Has(Position), ...queryFragments], { runOnInit: false });
+    const query = defineQuery(
+      [
+        Has(Position),
+        Has(Weight),
+        Has(ArrivalTime),
+        Has(EntityOwner),
+        NotValue(OwnedResourcesTracker, { resource_types: 0n }),
+      ],
+      { runOnInit: false },
+    );
 
     const handleArrivalUpdate = (arrivals: ArrivalInfo[], newArrival: ArrivalInfo | undefined) => {
       if (!newArrival) return arrivals;
 
-      if (!newArrival.hasResources || !newArrival.isHome) {
+      if (!newArrival.hasResources || !newArrival.isHome || !newArrival.isOwner) {
         return arrivals.filter((arrival) => arrival.entityId !== newArrival.entityId);
       }
 
@@ -147,10 +144,7 @@ const usePlayerArrivals = () => {
         isComponentUpdate(update, ArrivalTime) ||
         isComponentUpdate(update, OwnedResourcesTracker)
       ) {
-        const isThisMine = isMine(update.entity);
-
-        isThisMine &&
-          setEntitiesWithInventory((arrivals) => handleArrivalUpdate(arrivals, createArrivalInfo(update.entity)));
+        setEntitiesWithInventory((arrivals) => handleArrivalUpdate(arrivals, createArrivalInfo(update.entity)));
       }
     });
 
diff --git a/client/src/hooks/helpers/useEntities.tsx b/client/src/hooks/helpers/useEntities.tsx
index d32d1ca0c..c145b0c36 100644
--- a/client/src/hooks/helpers/useEntities.tsx
+++ b/client/src/hooks/helpers/useEntities.tsx
@@ -9,7 +9,7 @@ import {
   type ID,
 } from "@bibliothecadao/eternum";
 import { useEntityQuery } from "@dojoengine/react";
-import { Has, getComponentValue, type ComponentValue } from "@dojoengine/recs";
+import { Has, HasValue, getComponentValue, type ComponentValue } from "@dojoengine/recs";
 import { useMemo } from "react";
 import { shortString } from "starknet";
 import { useDojo } from "../context/DojoContext";
@@ -23,7 +23,7 @@ export type PlayerStructure = ComponentValue<ClientComponents["Structure"]["sche
   owner: ComponentValue<ClientComponents["Owner"]["schema"]>;
 };
 
-type RealmWithPosition = ComponentValue<ClientComponents["Realm"]["schema"]> & {
+export type RealmWithPosition = ComponentValue<ClientComponents["Realm"]["schema"]> & {
   position: ComponentValue<ClientComponents["Position"]["schema"]>;
   name: string;
   owner: ComponentValue<ClientComponents["Owner"]["schema"]>;
@@ -43,53 +43,18 @@ export const useEntities = () => {
   const { getEntityName } = useEntitiesUtils();
 
   // Get all realms
-  const allRealms = useEntityQuery([Has(Realm)]);
-
-  const filterPlayerRealms = useMemo(() => {
-    return allRealms.filter((id) => {
-      const owner = getComponentValue(Owner, id);
-      return owner && ContractAddress(owner.address) === ContractAddress(address);
-    });
-  }, [allRealms, address]);
-
-  const filterOtherRealms = useMemo(() => {
-    return allRealms.filter((id) => {
-      const owner = getComponentValue(Owner, id);
-      return owner && ContractAddress(owner.address) !== ContractAddress(address);
-    });
-  }, [allRealms, address]);
+  const playerRealmsQuery = useEntityQuery([Has(Realm), HasValue(Owner, { address: address })]);
 
   // Get all structures
-  const allStructures = useEntityQuery([Has(Structure), Has(Position), Has(Owner)]);
-
-  const filterPlayerStructures = useMemo(() => {
-    return allStructures.filter((id) => {
-      const owner = getComponentValue(Owner, id);
-      return owner && ContractAddress(owner.address) === ContractAddress(address);
-    });
-  }, [allStructures, address]);
-
-  const filterOtherStructures = useMemo(() => {
-    return allStructures.filter((id) => {
-      const owner = getComponentValue(Owner, id);
-      return owner && ContractAddress(owner.address) !== ContractAddress(address);
-    });
-  }, [allStructures, address]);
+  const playerStructuresQuery = useEntityQuery([
+    Has(Structure),
+    Has(Position),
+    Has(Owner),
+    HasValue(Owner, { address: address }),
+  ]);
 
   const playerRealms = useMemo(() => {
-    return filterPlayerRealms.map((id) => {
-      const realm = getComponentValue(Realm, id);
-      return {
-        ...realm,
-        position: getComponentValue(Position, id),
-        name: getRealmNameById(realm!.realm_id),
-        owner: getComponentValue(Owner, id),
-      } as RealmWithPosition;
-    });
-  }, [filterPlayerRealms]);
-
-  const otherRealms = useMemo(() => {
-    return filterOtherRealms.map((id) => {
+    return playerRealmsQuery.map((id) => {
       const realm = getComponentValue(Realm, id);
       return {
         ...realm,
@@ -98,10 +63,10 @@ export const useEntities = () => {
         owner: getComponentValue(Owner, id),
       } as RealmWithPosition;
     });
-  }, [filterOtherRealms]);
+  }, [playerRealmsQuery]);
 
   const playerStructures = useMemo(() => {
-    return filterPlayerStructures
+    return playerStructuresQuery
       .map((id) => {
         const structure = getComponentValue(Structure, id);
         if (!structure) return;
@@ -121,24 +86,7 @@ export const useEntities = () => {
         if (b.category === StructureType[StructureType.Realm]) return 1;
         return a.category.localeCompare(b.category);
       });
-  }, [filterPlayerStructures]);
-
-  const otherStructures = useMemo(() => {
-    return filterOtherStructures
-      .map((id) => {
-        const structure = getComponentValue(Structure, id);
-        if (!structure || structure.category === StructureType[StructureType.Realm]) return;
-
-        const position = getComponentValue(Position, id);
-
-        const structureName = getEntityName(structure.entity_id);
-
-        const name = structureName ? `${structure?.category} ${structureName}` : structure.category || "";
-        return { ...structure, position: position!, name, owner: getComponentValue(Owner, id) };
-      })
-      .filter((structure): structure is PlayerStructure => structure !== undefined)
-      .sort((a, b) => a.category.localeCompare(b.category));
-  }, [filterOtherStructures]);
+  }, [playerStructuresQuery]);
 
   const getPlayerRealms = (filterFn?: (realm: RealmWithPosition) => boolean) => {
     return useMemo(() => {
@@ -147,12 +95,6 @@ export const useEntities = () => {
     }, [playerRealms, filterFn]);
   };
 
-  const getOtherRealms = (filterFn?: (realm: RealmWithPosition) => boolean) => {
-    return useMemo(() => {
-      return filterFn ? otherRealms.filter(filterFn) : otherRealms;
-    }, [otherRealms, filterFn]);
-  };
-
   const getPlayerStructures = (filterFn?: (structure: PlayerStructure) => boolean) => {
     return useMemo(() => {
       const structures = filterFn ? playerStructures.filter(filterFn) : playerStructures;
@@ -160,17 +102,9 @@ export const useEntities = () => {
     }, [playerStructures, filterFn]);
   };
 
-  const getOtherStructures = (filterFn?: (structure: PlayerStructure) => boolean) => {
-    return useMemo(() => {
-      return filterFn ? otherStructures.filter(filterFn) : otherStructures;
-    }, [otherStructures, filterFn]);
-  };
-
   return {
     playerRealms: getPlayerRealms,
-    otherRealms: getOtherRealms,
     playerStructures: getPlayerStructures,
-    otherStructures: getOtherStructures,
   };
 };
 
diff --git a/client/src/hooks/helpers/useGuilds.tsx b/client/src/hooks/helpers/useGuilds.tsx
index 94e1e6ff5..b197add82 100644
--- a/client/src/hooks/helpers/useGuilds.tsx
+++ b/client/src/hooks/helpers/useGuilds.tsx
@@ -308,5 +308,6 @@ export const useGuilds = () => {
     usePlayerWhitelist,
     getGuildFromEntityId,
     getPlayersInPlayersGuild,
+    getPlayerListInGuild,
   };
 };
diff --git a/client/src/hooks/helpers/useRealm.tsx b/client/src/hooks/helpers/useRealm.tsx
index 88e2690d9..a62fb4bf7 100644
--- a/client/src/hooks/helpers/useRealm.tsx
+++ b/client/src/hooks/helpers/useRealm.tsx
@@ -2,12 +2,12 @@ import { type ClientComponents } from "@/dojo/createClientComponents";
 import { configManager } from "@/dojo/setup";
 import {
   ContractAddress,
-  type ID,
   getOrderName,
   getQuestResources as getStartingResources,
+  type ID,
 } from "@bibliothecadao/eternum";
 import { useEntityQuery } from "@dojoengine/react";
-import { type ComponentValue, type Entity, Has, HasValue, getComponentValue, runQuery } from "@dojoengine/recs";
+import { Has, HasValue, getComponentValue, runQuery, type ComponentValue, type Entity } from "@dojoengine/recs";
 import { useMemo } from "react";
 import { shortString } from "starknet";
 import realmIdsByOrder from "../../data/realmids_by_order.json";
@@ -265,7 +265,7 @@ export function getRealms(): RealmInfo[] {
       const position = getComponentValue(Position, entity);
       const population = getComponentValue(Population, entity);
 
-      if (!realm || !owner || !position) return;
+      if (!realm || !owner || !position) return null;
 
       const { realm_id, entity_id, produced_resources, order } = realm;
 
@@ -291,7 +291,7 @@ export function getRealms(): RealmInfo[] {
         hasWonder: realm.has_wonder,
       };
     })
-    .filter((realm) => realm !== undefined);
+    .filter((realm): realm is RealmInfo => realm !== null);
 }
 
 export function usePlayerRealms(): RealmInfo[] {
@@ -312,7 +312,7 @@ export function usePlayerRealms(): RealmInfo[] {
         const position = getComponentValue(Position, entity);
         const population = getComponentValue(Population, entity);
 
-        if (!realm || !owner || !position) return;
+        if (!realm || !owner || !position) return null;
 
         const { realm_id, entity_id, produced_resources, order } = realm;
 
@@ -338,7 +338,7 @@ export function usePlayerRealms(): RealmInfo[] {
           hasWonder: realm.has_wonder,
         };
       })
-      .filter((realm) => realm !== undefined);
+      .filter((realm): realm is RealmInfo => realm !== null);
   }, [realmEntities]);
   return realms;
 }
diff --git a/client/src/hooks/store/useUIStore.tsx b/client/src/hooks/store/useUIStore.tsx
index ff9f5878a..307f1e4bc 100644
--- a/client/src/hooks/store/useUIStore.tsx
+++ b/client/src/hooks/store/useUIStore.tsx
@@ -10,6 +10,7 @@ import { ThreeStore, createThreeStoreSlice } from "./_threeStore";
 import { BattleViewInfo } from "./types";
 import { BlockchainStore, createBlockchainStore } from "./useBlockchainStore";
 import { RealmStore, createRealmStoreSlice } from "./useRealmStore";
+import { WorldStore, createWorldStoreSlice } from "./useWorldLoading";
 
 type TooltipType = {
   content: React.ReactNode;
@@ -70,7 +71,7 @@ interface UIStore {
   setShowToS: (show: boolean) => void;
 }
 
-export type AppStore = UIStore & PopupsStore & ThreeStore & BuildModeStore & RealmStore & BlockchainStore;
+export type AppStore = UIStore & PopupsStore & ThreeStore & BuildModeStore & RealmStore & BlockchainStore & WorldStore;
 
 const useUIStore = create(
   subscribeWithSelector<AppStore>((set, get) => ({
@@ -139,6 +140,7 @@ const useUIStore = create(
     ...createBuildModeStoreSlice(set),
     ...createRealmStoreSlice(set),
     ...createBlockchainStore(set),
+    ...createWorldStoreSlice(set),
   })),
 );
 
diff --git a/client/src/hooks/store/useWorldLoading.tsx b/client/src/hooks/store/useWorldLoading.tsx
index f46ace82c..5a1ab77b5 100644
--- a/client/src/hooks/store/useWorldLoading.tsx
+++ b/client/src/hooks/store/useWorldLoading.tsx
@@ -1,20 +1,52 @@
-// World loading state
-import { create } from "zustand";
+/**
+ * Represents the loading state of different parts of the application.
+ * Each property indicates whether that part is currently loading data from the blockchain.
+ */
+export enum LoadingStateKey {
+  SelectedStructure = "selectedStructure",
+  Market = "market",
+  PlayerStructuresOneKey = "playerStructuresOneKey",
+  PlayerStructuresTwoKey = "playerStructuresTwoKey",
+  Arrivals = "arrivals",
+  Map = "map",
+  Bank = "bank",
+  World = "world",
+  Hyperstructure = "hyperstructure",
+  SingleKey = "singleKey",
+  Config = "config",
+  Events = "events",
+}
+
+export type LoadingState = {
+  [key in LoadingStateKey]: boolean;
+};
 
-interface WorldState {
-  isWorldLoading: boolean;
-  isMarketLoading: boolean;
-  isStructuresLoading: boolean;
-  setWorldLoading: (loading: boolean) => void;
-  setMarketLoading: (loading: boolean) => void;
-  setStructuresLoading: (loading: boolean) => void;
+export interface WorldStore {
+  loadingStates: LoadingState;
+  setLoading: (key: LoadingStateKey, value: boolean) => void;
 }
 
-export const useWorldStore = create<WorldState>((set) => ({
-  isWorldLoading: true,
-  isMarketLoading: true,
-  isStructuresLoading: true,  
-  setWorldLoading: (loading: boolean) => set({ isWorldLoading: loading }),
-  setMarketLoading: (loading: boolean) => set({ isMarketLoading: loading }),
-  setStructuresLoading: (loading: boolean) => set({ isStructuresLoading: loading }),
-}));
+export const createWorldStoreSlice = (set: any) => ({
+  loadingStates: {
+    [LoadingStateKey.SelectedStructure]: false,
+    [LoadingStateKey.Market]: false,
+    [LoadingStateKey.PlayerStructuresOneKey]: false,
+    [LoadingStateKey.PlayerStructuresTwoKey]: false,
+    [LoadingStateKey.Arrivals]: false,
+    [LoadingStateKey.Map]: false,
+    [LoadingStateKey.Bank]: false,
+    [LoadingStateKey.World]: false,
+    [LoadingStateKey.Hyperstructure]: false,
+    [LoadingStateKey.SingleKey]: false,
+    [LoadingStateKey.Config]: false,
+    [LoadingStateKey.Events]: false,
+  },
+
+  setLoading: (key: LoadingStateKey, value: boolean) =>
+    set((state: WorldStore) => ({
+      loadingStates: {
+        ...state.loadingStates,
+        [key]: value,
+      },
+    })),
+});
diff --git a/client/src/main.tsx b/client/src/main.tsx
index 4d97dc4ce..89f685c96 100644
--- a/client/src/main.tsx
+++ b/client/src/main.tsx
@@ -13,6 +13,7 @@ import App from "./App";
 import { setup } from "./dojo/setup";
 import { DojoProvider } from "./hooks/context/DojoContext";
 import { StarknetProvider } from "./hooks/context/starknet-provider";
+import useUIStore from "./hooks/store/useUIStore";
 import "./index.css";
 import GameRenderer from "./three/GameRenderer";
 import { PWAUpdatePopup } from "./ui/components/pwa-update-popup";
@@ -62,8 +63,10 @@ async function init() {
 
   root.render(<LoadingScreen backgroundImage={backgroundImage} />);
 
+  const state = useUIStore.getState();
+
   const setupStart = performance.now();
-  const setupResult = await setup(dojoConfig);
+  const setupResult = await setup({ state, ...dojoConfig });
   const setupEnd = performance.now();
   console.log("SetupEnd", setupEnd - setupStart);
 
diff --git a/client/src/three/scenes/Worldmap.ts b/client/src/three/scenes/Worldmap.ts
index 6af004669..734aa3eec 100644
--- a/client/src/three/scenes/Worldmap.ts
+++ b/client/src/three/scenes/Worldmap.ts
@@ -2,6 +2,7 @@ import { ArmyMovementManager, TravelPaths } from "@/dojo/modelManager/ArmyMoveme
 import { TileManager } from "@/dojo/modelManager/TileManager";
 import { SetupResult } from "@/dojo/setup";
 import useUIStore from "@/hooks/store/useUIStore";
+import { LoadingStateKey } from "@/hooks/store/useWorldLoading";
 import { soundSelector } from "@/hooks/useUISound";
 import { HexPosition, SceneName } from "@/types";
 import { Position } from "@/types/Position";
@@ -675,6 +676,7 @@ export default class WorldmapScene extends HexagonScene {
 
     // Create a unique key for this chunk range
     const chunkKey = `${startCol - range},${startCol + range},${startRow - range},${startRow + range}`;
+    console.log({ chunkKey });
 
     // Skip if we've already fetched this chunk
     if (this.fetchedChunks.has(chunkKey)) {
@@ -687,6 +689,7 @@ export default class WorldmapScene extends HexagonScene {
     console.log(startCol, startRow, range);
 
     try {
+      this.state.setLoading(LoadingStateKey.Map, true);
       const promiseTiles = getEntities(
         this.dojo.network.toriiClient,
         {
@@ -734,62 +737,62 @@ export default class WorldmapScene extends HexagonScene {
         1000,
         false,
       );
-      // const promisePositions = getEntities(
-      //   this.dojo.network.toriiClient,
-      //   {
-      //     Composite: {
-      //       operator: "And",
-      //       clauses: [
-      //         {
-      //           Composite: {
-      //             operator: "And",
-      //             clauses: [
-      //               {
-      //                 Member: {
-      //                   model: "s0_eternum-Position",
-      //                   member: "x",
-      //                   operator: "Gte",
-      //                   value: { Primitive: { U32: startCol - range } },
-      //                 },
-      //               },
-      //               {
-      //                 Member: {
-      //                   model: "s0_eternum-Position",
-      //                   member: "x",
-      //                   operator: "Lte",
-      //                   value: { Primitive: { U32: startCol + range } },
-      //                 },
-      //               },
-      //               {
-      //                 Member: {
-      //                   model: "s0_eternum-Position",
-      //                   member: "y",
-      //                   operator: "Gte",
-      //                   value: { Primitive: { U32: startRow - range } },
-      //                 },
-      //               },
-      //               {
-      //                 Member: {
-      //                   model: "s0_eternum-Position",
-      //                   member: "y",
-      //                   operator: "Lte",
-      //                   value: { Primitive: { U32: startRow + range } },
-      //                 },
-      //               },
-      //             ],
-      //           },
-      //         },
-      //       ],
-      //     },
-      //   },
-      //   this.dojo.network.contractComponents as any,
-      //   [],
-      //   ["s0_eternum-Tile"],
-      //   1000,
-      //   false,
-      // );
-      Promise.all([promiseTiles]).then(([tiles]) => {
-        // console.log(tiles, positions);
+      const promisePositions = getEntities(
+        this.dojo.network.toriiClient,
+        {
+          Composite: {
+            operator: "And",
+            clauses: [
+              {
+                Member: {
+                  model: "s0_eternum-Position",
+                  member: "x",
+                  operator: "Gte",
+                  value: { Primitive: { U32: startCol - range } },
+                },
+              },
+              {
+                Member: {
+                  model: "s0_eternum-Position",
+                  member: "x",
+                  operator: "Lte",
+                  value: { Primitive: { U32: startCol + range } },
+                },
+              },
+              {
+                Member: {
+                  model: "s0_eternum-Position",
+                  member: "y",
+                  operator: "Gte",
+                  value: { Primitive: { U32: startRow - range } },
+                },
+              },
+              {
+                Member: {
+                  model: "s0_eternum-Position",
+                  member: "y",
+                  operator: "Lte",
+                  value: { Primitive: { U32: startRow + range } },
+                },
+              },
+            ],
+          },
+        },
+        this.dojo.network.contractComponents as any,
+        [],
+        [
+          "s0_eternum-Army",
+          "s0_eternum-Position",
+          "s0_eternum-Health",
+          "s0_eternum-EntityOwner",
+          "s0_eternum-Protectee",
+          "s0_eternum-Stamina",
+        ],
+        1000,
+        false,
+      );
+      Promise.all([promiseTiles, promisePositions]).then(() => {
+        this.state.setLoading(LoadingStateKey.Map, false);
       });
     } catch (error) {
       // If there's an error, remove the chunk from cached set so it can be retried
diff --git a/client/src/three/systems/SystemManager.ts b/client/src/three/systems/SystemManager.ts
index 4c819ace5..8b5afe1c5 100644
--- a/client/src/three/systems/SystemManager.ts
+++ b/client/src/three/systems/SystemManager.ts
@@ -87,6 +87,7 @@ export class SystemManager {
             isComponentUpdate(update, this.setup.components.Health)
           ) {
             const army = getComponentValue(this.setup.components.Army, update.entity);
+
             if (!army) return;
 
             const position = getComponentValue(this.setup.components.Position, update.entity);
diff --git a/client/src/ui/components/WorldLoading.tsx b/client/src/ui/components/WorldLoading.tsx
new file mode 100644
index 000000000..71d753486
--- /dev/null
+++ b/client/src/ui/components/WorldLoading.tsx
@@ -0,0 +1,46 @@
+import useUIStore from "@/hooks/store/useUIStore";
+import { LoadingStateKey } from "@/hooks/store/useWorldLoading";
+
+export const WorldLoading = () => {
+  const loadingStates = useUIStore((state) => state.loadingStates);
+
+  const anyLoading = Object.values(loadingStates).some((isLoading) => isLoading);
+
+  const getLoadingItems = () => {
+    const items = [];
+    if (loadingStates[LoadingStateKey.SelectedStructure]) items.push("Selected Structure");
+    if (loadingStates[LoadingStateKey.Market]) items.push("Market");
+    if (loadingStates[LoadingStateKey.PlayerStructuresOneKey] || loadingStates[LoadingStateKey.PlayerStructuresTwoKey])
+      items.push("Player Structures");
+    if (loadingStates[LoadingStateKey.Arrivals]) items.push("Arrivals");
+    if (loadingStates[LoadingStateKey.Map]) items.push("Map");
+    if (loadingStates[LoadingStateKey.Bank]) items.push("Bank");
+    if (loadingStates[LoadingStateKey.World]) items.push("World");
+    if (loadingStates[LoadingStateKey.Hyperstructure]) items.push("Hyperstructure");
+    if (loadingStates[LoadingStateKey.SingleKey]) items.push("Single Key");
+    if (loadingStates[LoadingStateKey.Config]) items.push("Config");
+    if (loadingStates[LoadingStateKey.Events]) items.push("Events");
+    return items.join(", ");
+  };
+
+  return (
+    <div
+      className={`
+        z-1000
+        fixed left-1/2 transform -translate-x-1/2
+        bg-black/80 p-2 rounded-lg
+        transition-all duration-200 ease-in-out
+        origin-bottom scale-75 md:scale-100
+        ${anyLoading ? "bottom-0 opacity-100" : "translate-y-full opacity-0"}
+      `}
+      id="world-loading"
+    >
+      {anyLoading && (
+        <div className="flex flex-row items-center justify-center h-full p-2">
+          <img src="/images/eternumloader.png" className="w-10" />
+          <div className="ml-4">Loading: {getLoadingItems()}</div>
+        </div>
+      )}
+    </div>
+  );
+};
diff --git a/client/src/ui/components/resources/InventoryResources.tsx b/client/src/ui/components/resources/InventoryResources.tsx
index 0b4b7cd2f..235d28010 100644
--- a/client/src/ui/components/resources/InventoryResources.tsx
+++ b/client/src/ui/components/resources/InventoryResources.tsx
@@ -1,4 +1,4 @@
-import { addToSubscription } from "@/dojo/queries";
+import { debouncedAddToSubscription } from "@/dojo/debouncedQueries";
 import { useDojo } from "@/hooks/context/DojoContext";
 import { useResourceBalance, useResourcesUtils } from "@/hooks/helpers/useResources";
 import { ResourceCost } from "@/ui/elements/ResourceCost";
@@ -52,7 +52,7 @@ export const InventoryResources = ({
       setIsSyncing(true);
       try {
         console.log("AddToSubscriptionStart - 4");
-        await addToSubscription(dojo.network.toriiClient, dojo.network.contractComponents as any, [
+        await debouncedAddToSubscription(dojo.network.toriiClient, dojo.network.contractComponents as any, [
           entityId.toString(),
         ]);
         localStorage.setItem(cacheKey, now.toString());
diff --git a/client/src/ui/components/trading/MarketModal.tsx b/client/src/ui/components/trading/MarketModal.tsx
index b46a2e1ca..aafb821e3 100644
--- a/client/src/ui/components/trading/MarketModal.tsx
+++ b/client/src/ui/components/trading/MarketModal.tsx
@@ -15,7 +15,6 @@ import { useSetMarket } from "@/hooks/helpers/useTrade";
 import useMarketStore from "@/hooks/store/useMarketStore";
 import { useModalStore } from "@/hooks/store/useModalStore";
 import useUIStore from "@/hooks/store/useUIStore";
-import { useWorldStore } from "@/hooks/store/useWorldLoading";
 import { BuildingThumbs } from "@/ui/config";
 import CircleButton from "@/ui/elements/CircleButton";
 import { LoadingAnimation } from "@/ui/elements/LoadingAnimation";
@@ -61,8 +60,6 @@ export const MarketModal = () => {
   const bank = banks.length === 1 ? banks[0] : null;
   const battles = useBattlesByPosition(bank?.position || { x: 0, y: 0 });
 
-  const isMarketLoading = useWorldStore((state) => state.isMarketLoading);
-
   const currentBlockTimestamp = useUIStore.getState().nextBlockTimestamp || 0;
 
   const getStructure = useStructureByPosition();
@@ -342,14 +339,6 @@ export const MarketModal = () => {
           </Tabs>
         </div>
       </div>
-      {isMarketLoading && (
-        <div className="absolute bottom-4 inset-x-0 z-10 flex justify-center pointer-events-none">
-          <div className="bg-brown/90 text-sm px-4 py-1 rounded-t-lg border border-gold/30 flex items-center gap-2">
-            <div className="w-2 h-2 bg-gold/50 rounded-full animate-pulse" />
-            <span>Syncing market data...</span>
-          </div>
-        </div>
-      )}
     </ModalContainer>
   );
 };
diff --git a/client/src/ui/components/trading/MarketOrderPanel.tsx b/client/src/ui/components/trading/MarketOrderPanel.tsx
index 031e46a29..749af7cc3 100644
--- a/client/src/ui/components/trading/MarketOrderPanel.tsx
+++ b/client/src/ui/components/trading/MarketOrderPanel.tsx
@@ -451,7 +451,7 @@ const OrderRow = memo(
           <ConfirmationPopup
             title="Confirm Trade"
             onConfirm={onAccept}
-            disabled={donkeysNeeded > donkeyBalance || donkeyBalance === 0}
+            disabled={!isBuy && donkeysNeeded > donkeyBalance}
             onCancel={() => {
               setConfirmOrderModal(false);
             }}
@@ -600,7 +600,7 @@ const OrderCreation = memo(
 
     const enoughDonkeys = useMemo(() => {
       if (resourceId === ResourcesIds.Donkey) return true;
-      return donkeyBalance > donkeysNeeded;
+      return donkeyBalance >= donkeysNeeded;
     }, [donkeyBalance, donkeysNeeded, resourceId]);
 
     return (
diff --git a/client/src/ui/components/trading/ResourceArrivals.tsx b/client/src/ui/components/trading/ResourceArrivals.tsx
index d12b766f1..a1a86b841 100644
--- a/client/src/ui/components/trading/ResourceArrivals.tsx
+++ b/client/src/ui/components/trading/ResourceArrivals.tsx
@@ -1,16 +1,38 @@
 import { addToSubscription } from "@/dojo/queries";
 import { useDojo } from "@/hooks/context/DojoContext";
 import { ArrivalInfo } from "@/hooks/helpers/use-resource-arrivals";
+import useNextBlockTimestamp from "@/hooks/useNextBlockTimestamp";
+import Button from "@/ui/elements/Button";
+import { Checkbox } from "@/ui/elements/Checkbox";
 import { Headline } from "@/ui/elements/Headline";
 import { HintModalButton } from "@/ui/elements/HintModalButton";
 import { memo, useEffect, useState } from "react";
+import { create } from "zustand";
 import { EntityArrival } from "../entities/Entity";
 import { HintSection } from "../hints/HintModal";
 
+const DISPLAYED_ARRIVALS = 3;
+interface SubscribedIdsStore {
+  subscribedIds: Set<string>;
+  addSubscribedIds: (ids: string[]) => void;
+}
+
+const useSubscribedIdsStore = create<SubscribedIdsStore>((set) => ({
+  subscribedIds: new Set<string>(),
+  addSubscribedIds: (ids) =>
+    set((state) => ({
+      subscribedIds: new Set([...state.subscribedIds, ...ids]),
+    })),
+}));
+
 export const AllResourceArrivals = memo(
   ({ arrivals, className = "" }: { arrivals: ArrivalInfo[]; className?: string }) => {
     const dojo = useDojo();
-    const [subscribedIds, setSubscribedIds] = useState<Set<string>>(new Set());
+    const [displayCount, setDisplayCount] = useState(DISPLAYED_ARRIVALS);
+    const [showOnlyArrived, setShowOnlyArrived] = useState(true);
+
+    const { nextBlockTimestamp } = useNextBlockTimestamp();
+    const { subscribedIds, addSubscribedIds } = useSubscribedIdsStore();
 
     useEffect(() => {
       // Create a single Set from newIds for O(1) lookup
@@ -21,19 +43,26 @@ export const AllResourceArrivals = memo(
 
       if (unsubscribedIds.length === 0) return;
 
-      // Batch the state update with the API call
-      setSubscribedIds((prev) => {
-        // If nothing changed, return the previous state to prevent re-render
-        if (unsubscribedIds.every((id) => prev.has(id))) return prev;
-        return new Set([...prev, ...unsubscribedIds]);
-      });
+      // Update zustand store
+      addSubscribedIds(unsubscribedIds);
 
       // Move API call outside of state updates
       addToSubscription(dojo.network.toriiClient, dojo.network.contractComponents as any, unsubscribedIds).catch(
         (error) => console.error("Fetch failed", error),
       );
       console.log("AddToSubscriptionStart - 5");
-    }, [arrivals, subscribedIds]);
+    }, [arrivals, subscribedIds, addSubscribedIds]);
+
+    const filteredArrivals = showOnlyArrived
+      ? arrivals.filter((arrival) => arrival.arrivesAt < nextBlockTimestamp)
+      : arrivals;
+
+    const displayedArrivals = filteredArrivals.slice(0, displayCount);
+    const hasMore = displayCount < filteredArrivals.length;
+
+    const loadMore = () => {
+      setDisplayCount((prev) => Math.min(prev + DISPLAYED_ARRIVALS, filteredArrivals.length));
+    };
 
     return (
       <div className={`p-2 flex flex-col space-y-1 overflow-y-auto gap-2 ${className}`}>
@@ -43,9 +72,22 @@ export const AllResourceArrivals = memo(
             <HintModalButton section={HintSection.Transfers} />
           </div>
         </Headline>
-        {arrivals.map((arrival) => (
+        <div className="px-2 pb-2">
+          <label className="flex items-center space-x-1 text-xs">
+            <Checkbox enabled={showOnlyArrived} onClick={() => setShowOnlyArrived(!showOnlyArrived)} />
+            <span>Show only arrived</span>
+          </label>
+        </div>
+        {displayedArrivals.map((arrival) => (
           <EntityArrival arrival={arrival} key={arrival.entityId} />
         ))}
+        {hasMore && (
+          <div className="text-center py-4">
+            <Button onClick={loadMore} variant="default" size="xs">
+              Load More
+            </Button>
+          </div>
+        )}
       </div>
     );
   },
diff --git a/client/src/ui/components/trading/SelectResources.tsx b/client/src/ui/components/trading/SelectResources.tsx
index f5abae5e9..cdfdf1c16 100644
--- a/client/src/ui/components/trading/SelectResources.tsx
+++ b/client/src/ui/components/trading/SelectResources.tsx
@@ -5,7 +5,7 @@ import ListSelect from "@/ui/elements/ListSelect";
 import { NumberInput } from "@/ui/elements/NumberInput";
 import { ResourceCost } from "@/ui/elements/ResourceCost";
 import { divideByPrecision } from "@/ui/utils/utils";
-import { ID, resources } from "@bibliothecadao/eternum";
+import { ID, RESOURCE_TIERS, ResourcesIds, resources } from "@bibliothecadao/eternum";
 import { useMemo } from "react";
 
 export const SelectResources = ({
@@ -24,8 +24,18 @@ export const SelectResources = ({
   const { getBalance } = useResourceBalance();
   const { playResourceSound } = usePlayResourceSound();
 
+  const orderedResources = useMemo(() => {
+    return Object.values(RESOURCE_TIERS)
+      .flat()
+      .filter((resourceId) => resourceId !== ResourcesIds.Lords)
+      .map((resourceId) => ({
+        id: resourceId,
+        trait: ResourcesIds[resourceId],
+      }));
+  }, []);
+
   const unselectedResources = useMemo(
-    () => resources.filter((res) => !selectedResourceIds.includes(res.id)),
+    () => orderedResources.filter((res) => !selectedResourceIds.includes(res.id)),
     [selectedResourceIds],
   );
 
@@ -39,10 +49,11 @@ export const SelectResources = ({
   };
 
   return (
-    <div className=" items-center col-span-4 space-y-2 p-3">
+    <div className="items-center col-span-4 space-y-2 p-3">
       {selectedResourceIds.map((id: any, index: any) => {
         const resource = getBalance(entity_id, id);
-        const options = [resources.find((res) => res.id === id), ...unselectedResources].map((res: any) => ({
+
+        const options = [orderedResources.find((res) => res.id === id), ...unselectedResources].map((res: any) => ({
           id: res.id,
           label: (
             <ResourceCost resourceId={res.id} amount={divideByPrecision(getBalance(entity_id, res.id)?.balance || 0)} />
@@ -65,7 +76,10 @@ export const SelectResources = ({
               </Button>
             )}
             <ListSelect
-              options={options}
+              options={options.map((option) => ({
+                ...option,
+                searchText: resources.find((res) => res.id === option.id)?.trait,
+              }))}
               value={selectedResourceIds[index]}
               onChange={(value) => {
                 const updatedResourceIds = [...selectedResourceIds];
@@ -77,6 +91,7 @@ export const SelectResources = ({
                 });
                 playResourceSound(value);
               }}
+              enableFilter={true}
             />
             <NumberInput
               className="h-14 "
diff --git a/client/src/ui/components/trading/TransferBetweenEntities.tsx b/client/src/ui/components/trading/TransferBetweenEntities.tsx
index e2a004fd7..540b070d9 100644
--- a/client/src/ui/components/trading/TransferBetweenEntities.tsx
+++ b/client/src/ui/components/trading/TransferBetweenEntities.tsx
@@ -7,7 +7,7 @@ import Button from "@/ui/elements/Button";
 import { Checkbox } from "@/ui/elements/Checkbox";
 import { Headline } from "@/ui/elements/Headline";
 import TextInput from "@/ui/elements/TextInput";
-import { multiplyByPrecision } from "@/ui/utils/utils";
+import { multiplyByPrecision, normalizeDiacriticalMarks } from "@/ui/utils/utils";
 import { DONKEY_ENTITY_TYPE, ID } from "@bibliothecadao/eternum";
 import { ArrowRight, LucideArrowRight } from "lucide-react";
 import { memo, useEffect, useMemo, useState } from "react";
@@ -76,11 +76,13 @@ const SelectEntitiesStep = memo(
     };
 
     const filterEntities = (entities: any[], searchTerm: string, selectedEntityId: ID | undefined) => {
+      const normalizedSearchTerm = normalizeDiacriticalMarks(searchTerm.toLowerCase());
       return entities.filter(
         (entity) =>
           entity.entity_id === selectedEntityId ||
-          entity.name.toLowerCase().includes(searchTerm.toLowerCase()) ||
-          (entity.accountName && entity.accountName.toLowerCase().includes(searchTerm.toLowerCase())),
+          normalizeDiacriticalMarks(entity.name.toLowerCase()).includes(normalizedSearchTerm) ||
+          (entity.accountName &&
+            normalizeDiacriticalMarks(entity.accountName.toLowerCase()).includes(normalizedSearchTerm)),
       );
     };
 
@@ -319,9 +321,17 @@ export const TransferBetweenEntities = ({
             </div>
           </div>
 
-          <div className="w-full col-span-2">
+          <div className="w-full col-span-2 grid grid-cols-4 gap-4">
             <Button
-              className="w-full justify-center"
+              className="col-span-1 justify-center"
+              variant="secondary"
+              size="md"
+              onClick={() => setSelectedStepId(STEP_ID.SELECT_ENTITIES)}
+            >
+              Back
+            </Button>
+            <Button
+              className="col-span-3 justify-center"
               isLoading={isLoading}
               disabled={!canCarry || selectedResourceIds.length === 0}
               variant="primary"
diff --git a/client/src/ui/components/trading/TransferView.tsx b/client/src/ui/components/trading/TransferView.tsx
index 13161bb6c..4ff0933b4 100644
--- a/client/src/ui/components/trading/TransferView.tsx
+++ b/client/src/ui/components/trading/TransferView.tsx
@@ -1,15 +1,22 @@
 import { useDojo } from "@/hooks/context/DojoContext";
-import { useEntities } from "@/hooks/helpers/useEntities";
+import { PlayerStructure, RealmWithPosition, useEntities, useEntitiesUtils } from "@/hooks/helpers/useEntities";
 import { useGuilds } from "@/hooks/helpers/useGuilds";
+import { getRealmNameById } from "@/ui/utils/realms";
+import { ContractAddress, StructureType } from "@bibliothecadao/eternum";
+import { useEntityQuery } from "@dojoengine/react";
+import { Has, NotValue, getComponentValue } from "@dojoengine/recs";
 import { useMemo, useState } from "react";
 import { TransferBetweenEntities } from "./TransferBetweenEntities";
 
 export const TransferView = () => {
   const {
     account: { account },
+    setup: {
+      components: { Structure, Position, Owner, Realm },
+    },
   } = useDojo();
 
-  const { playerRealms, playerStructures, otherRealms, otherStructures } = useEntities();
+  const { playerRealms, playerStructures } = useEntities();
 
   const [guildOnly, setGuildOnly] = useState(false);
 
@@ -19,6 +26,46 @@ export const TransferView = () => {
     return getPlayersInPlayersGuild(BigInt(account.address)).map((a) => BigInt(a.address));
   }, [account.address]);
 
+  const { getEntityName } = useEntitiesUtils();
+
+  const otherStructuresQuery = useEntityQuery([
+    Has(Structure),
+    Has(Position),
+    Has(Owner),
+    NotValue(Owner, { address: ContractAddress(account.address) }),
+  ]);
+
+  const otherStructures = useMemo(() => {
+    return otherStructuresQuery
+      .map((id) => {
+        const structure = getComponentValue(Structure, id);
+        if (!structure || structure.category === StructureType[StructureType.Realm]) return;
+
+        const position = getComponentValue(Position, id);
+
+        const structureName = getEntityName(structure.entity_id);
+
+        const name = structureName ? `${structure?.category} ${structureName}` : structure.category || "";
+        return { ...structure, position: position!, name, owner: getComponentValue(Owner, id) };
+      })
+      .filter((structure): structure is PlayerStructure => structure !== undefined)
+      .sort((a, b) => a.category.localeCompare(b.category));
+  }, [otherStructuresQuery]);
+
+  const otherRealmsQuery = useEntityQuery([Has(Realm), NotValue(Owner, { address: ContractAddress(account.address) })]);
+
+  const otherRealms = useMemo(() => {
+    return otherRealmsQuery.map((id) => {
+      const realm = getComponentValue(Realm, id);
+      return {
+        ...realm,
+        position: getComponentValue(Position, id),
+        name: getRealmNameById(realm!.realm_id),
+        owner: getComponentValue(Owner, id),
+      } as RealmWithPosition;
+    });
+  }, [otherRealmsQuery]);
+
   return (
     <TransferBetweenEntities
       filterBy={setGuildOnly}
@@ -38,7 +85,7 @@ export const TransferView = () => {
           name: "Your Banks",
         },
         {
-          entities: otherRealms((a) =>
+          entities: otherRealms.filter((a) =>
             guildOnly
               ? playersInPlayersGuildAddress.includes(a.owner.address)
               : !playersInPlayersGuildAddress.includes(a.owner.address),
@@ -46,7 +93,7 @@ export const TransferView = () => {
           name: "Other Realms",
         },
         {
-          entities: otherStructures((a) =>
+          entities: otherStructures.filter((a) =>
             guildOnly
               ? playersInPlayersGuildAddress.includes(a.owner.address)
               : !playersInPlayersGuildAddress.includes(a.owner.address),
diff --git a/client/src/ui/components/worldmap/armies/SelectedArmy.tsx b/client/src/ui/components/worldmap/armies/SelectedArmy.tsx
index 4897a64fe..bfb023583 100644
--- a/client/src/ui/components/worldmap/armies/SelectedArmy.tsx
+++ b/client/src/ui/components/worldmap/armies/SelectedArmy.tsx
@@ -2,7 +2,6 @@ import { useOwnArmiesByPosition } from "@/hooks/helpers/useArmies";
 import { useEntities } from "@/hooks/helpers/useEntities";
 import { useQuery } from "@/hooks/helpers/useQuery";
 import useUIStore from "@/hooks/store/useUIStore";
-import { useWorldStore } from "@/hooks/store/useWorldLoading";
 import { Position } from "@/types/Position";
 import { ArmyChip } from "@/ui/components/military/ArmyChip";
 import { InventoryResources } from "@/ui/components/resources/InventoryResources";
@@ -15,8 +14,6 @@ export const SelectedArmy = () => {
   const updateSelectedEntityId = useUIStore((state) => state.updateSelectedEntityId);
   const { isMapView } = useQuery();
 
-  const isWorldLoading = useWorldStore((state) => state.isWorldLoading);
-
   const [selectedArmyIndex, setSelectedArmyIndex] = useState(0);
 
   useEffect(() => {
@@ -66,52 +63,34 @@ export const SelectedArmy = () => {
   const showTooltip = selectedHex && ownArmy && isMapView;
 
   return (
-    <>
-      <div
-        className={`
-        fixed left-1/2 transform -translate-x-1/2
-        bg-black/80 p-2 rounded-lg
-        transition-all duration-200 ease-in-out
-        origin-bottom scale-75 md:scale-100
-        ${isWorldLoading ? "bottom-0 opacity-100" : "translate-y-full opacity-0"}
-      `}
-      >
-        {isWorldLoading && (
-          <div className="flex flex-row items-center justify-center h-full p-2">
-            <img src="/images/eternumloader.png" className="w-10" />
-            <div className="ml-4">World state is loading...</div>
-          </div>
-        )}
-      </div>
-      <div
-        className={`
+    <div
+      className={`
         fixed left-1/2 transform -translate-x-1/2
         bg-black/80 p-2 rounded-lg
         transition-all duration-200 ease-in-out
         origin-bottom scale-75 md:scale-100
         ${showTooltip ? "bottom-0 opacity-100" : "translate-y-full opacity-0"}
       `}
-      >
-        {showTooltip && (
-          <div>
-            {userArmies.length > 1 && (
-              <div className="flex flex-row justify-between mt-2">
-                <div className="px-2 py-1 text-sm rounded-tl animate-pulse">Press Tab to cycle through armies</div>
-                <div className="px-2 py-1 text-sm rounded-bl ">
-                  Army {selectedArmyIndex + 1}/{userArmies.length}
-                </div>
+    >
+      {showTooltip && (
+        <div>
+          {userArmies.length > 1 && (
+            <div className="flex flex-row justify-between mt-2">
+              <div className="px-2 py-1 text-sm rounded-tl animate-pulse">Press Tab to cycle through armies</div>
+              <div className="px-2 py-1 text-sm rounded-bl ">
+                Army {selectedArmyIndex + 1}/{userArmies.length}
               </div>
-            )}
-            <ArmyWarning army={ownArmy!} />
-            <ArmyChip className="w-[27rem] bg-black/90" army={ownArmy} showButtons={false} />
-            <InventoryResources
-              entityId={ownArmy!.entity_id}
-              className="flex gap-1 h-14 mt-2 overflow-x-auto no-scrollbar"
-              resourcesIconSize="xs"
-            />
-          </div>
-        )}
-      </div>
-    </>
+            </div>
+          )}
+          <ArmyWarning army={ownArmy!} />
+          <ArmyChip className="w-[27rem] bg-black/90" army={ownArmy} showButtons={false} />
+          <InventoryResources
+            entityId={ownArmy!.entity_id}
+            className="flex gap-1 h-14 mt-2 overflow-x-auto no-scrollbar"
+            resourcesIconSize="xs"
+          />
+        </div>
+      )}
+    </div>
   );
 };
diff --git a/client/src/ui/components/worldmap/players/PlayerList.tsx b/client/src/ui/components/worldmap/players/PlayerList.tsx
index 1431ef3d9..b36ef8622 100644
--- a/client/src/ui/components/worldmap/players/PlayerList.tsx
+++ b/client/src/ui/components/worldmap/players/PlayerList.tsx
@@ -38,11 +38,16 @@ export const PlayerList = ({
     sort: "none",
   });
 
+  const sortedPlayers = useMemo(
+    () => sortItems(players, activeSort, { sortKey: "rank", sort: "asc" }),
+    [players, activeSort],
+  );
+
   return (
     <div className="flex flex-col h-full p-2 bg-brown-900/50 border border-gold/30 rounded-xl backdrop-blur-sm">
       <PlayerListHeader activeSort={activeSort} setActiveSort={setActiveSort} />
       <div className="mt-4 overflow-y-auto scrollbar-thin scrollbar-thumb-gold/20 scrollbar-track-transparent">
-        {sortItems(players, activeSort, { sortKey: "rank", sort: "asc" }).map((player) => (
+        {sortedPlayers.map((player) => (
           <PlayerRow
             key={player.address}
             player={player}
diff --git a/client/src/ui/components/worldmap/players/PlayersPanel.tsx b/client/src/ui/components/worldmap/players/PlayersPanel.tsx
index 836ef5afb..8b6ec2409 100644
--- a/client/src/ui/components/worldmap/players/PlayersPanel.tsx
+++ b/client/src/ui/components/worldmap/players/PlayersPanel.tsx
@@ -3,7 +3,7 @@ import { useEntitiesUtils } from "@/hooks/helpers/useEntities";
 import { useGuilds } from "@/hooks/helpers/useGuilds";
 import Button from "@/ui/elements/Button";
 import TextInput from "@/ui/elements/TextInput";
-import { getEntityIdFromKeys, toHexString } from "@/ui/utils/utils";
+import { getEntityIdFromKeys, normalizeDiacriticalMarks, toHexString } from "@/ui/utils/utils";
 import { ContractAddress, Player } from "@bibliothecadao/eternum";
 import { Has, HasValue, getComponentValue, runQuery } from "@dojoengine/recs";
 import { KeyboardEvent, useMemo, useState } from "react";
@@ -70,20 +70,23 @@ export const PlayersPanel = ({
       };
     });
     return playersWithStructures;
-  }, [isLoading]);
+  }, [isLoading, players]);
 
   const filteredPlayers = useMemo(() => {
-    const term = searchTerm.toLowerCase();
+    const normalizedTerm = normalizeDiacriticalMarks(searchTerm.toLowerCase());
+
     return searchTerm === ""
       ? playersWithStructures
       : playersWithStructures.filter((player) => {
-          const nameMatch = player.name.toLowerCase().includes(term);
+          const nameMatch = normalizeDiacriticalMarks(player.name.toLowerCase()).includes(normalizedTerm);
           if (nameMatch) return true;
 
-          const addressMatch = toHexString(player.address).toLowerCase().includes(term);
+          const addressMatch = toHexString(player.address).toLowerCase().includes(normalizedTerm);
           if (addressMatch) return true;
 
-          return player.structures.some((structure) => structure && structure.toLowerCase().includes(term));
+          return player.structures.some(
+            (structure) => structure && normalizeDiacriticalMarks(structure.toLowerCase()).includes(normalizedTerm),
+          );
         });
   }, [playersWithStructures, searchTerm]);
 
diff --git a/client/src/ui/containers/BaseContainer.tsx b/client/src/ui/containers/BaseContainer.tsx
index 58b6985f7..01130d30d 100644
--- a/client/src/ui/containers/BaseContainer.tsx
+++ b/client/src/ui/containers/BaseContainer.tsx
@@ -1,7 +1,7 @@
 import { ReactComponent as Collapse } from "@/assets/icons/common/collapse.svg";
 import { ReactComponent as Expand } from "@/assets/icons/common/expand.svg";
 import clsx from "clsx";
-import { forwardRef, ReactNode, useState } from "react";
+import { forwardRef, memo, ReactNode, useState } from "react";
 
 interface BaseContainerProps {
   children?: ReactNode;
@@ -11,38 +11,40 @@ interface BaseContainerProps {
   collapsedClassName?: string;
   scrollbarSide?: "left" | "right";
 }
-export const BaseContainer = forwardRef<HTMLDivElement, BaseContainerProps>(
-  (
-    { children, className, expandable, expandedClassName, collapsedClassName, scrollbarSide }: BaseContainerProps,
-    ref,
-  ) => {
-    const [expanded, setExpanded] = useState(false);
-    return (
-      <div
-        ref={ref}
-        className={clsx(
-          "flex relative flex-col transition-all duration-400 bg-brown/90 bg-hex-bg animatedBackground",
-          {
-            "[direction:rtl]": scrollbarSide === "left",
-          },
-          className,
-          expanded ? expandedClassName : collapsedClassName,
-        )}
-      >
-        {children}
-        {expandable &&
-          (expanded ? (
-            <Collapse
-              onClick={() => setExpanded(false)}
-              className="absolute w-4 h-4 transition-colors duration-200 cursor-pointer top-4 right-4 fill-gold hover:fill-white"
-            />
-          ) : (
-            <Expand
-              onClick={() => setExpanded(true)}
-              className="absolute w-4 h-4 transition-colors duration-200 cursor-pointer top-4 right-4 fill-gold hover:fill-white"
-            />
-          ))}
-      </div>
-    );
-  },
+export const BaseContainer = memo(
+  forwardRef<HTMLDivElement, BaseContainerProps>(
+    (
+      { children, className, expandable, expandedClassName, collapsedClassName, scrollbarSide }: BaseContainerProps,
+      ref,
+    ) => {
+      const [expanded, setExpanded] = useState(false);
+      return (
+        <div
+          ref={ref}
+          className={clsx(
+            "flex relative flex-col transition-all duration-400 bg-brown/90 bg-hex-bg animatedBackground",
+            {
+              "[direction:rtl]": scrollbarSide === "left",
+            },
+            className,
+            expanded ? expandedClassName : collapsedClassName,
+          )}
+        >
+          {children}
+          {expandable &&
+            (expanded ? (
+              <Collapse
+                onClick={() => setExpanded(false)}
+                className="absolute w-4 h-4 transition-colors duration-200 cursor-pointer top-4 right-4 fill-gold hover:fill-white"
+              />
+            ) : (
+              <Expand
+                onClick={() => setExpanded(true)}
+                className="absolute w-4 h-4 transition-colors duration-200 cursor-pointer top-4 right-4 fill-gold hover:fill-white"
+              />
+            ))}
+        </div>
+      );
+    },
+  ),
 );
diff --git a/client/src/ui/containers/BattleContainer.tsx b/client/src/ui/containers/BattleContainer.tsx
index 99ead1cd5..4d7ecb591 100644
--- a/client/src/ui/containers/BattleContainer.tsx
+++ b/client/src/ui/containers/BattleContainer.tsx
@@ -1,7 +1,7 @@
 import useUIStore from "@/hooks/store/useUIStore";
-import { useEffect } from "react";
+import { memo, useEffect } from "react";
 
-export const BattleContainer = ({ children }: { children: React.ReactNode }) => {
+export const BattleContainer = memo(({ children }: { children: React.ReactNode }) => {
   const setBattleView = useUIStore((state) => state.setBattleView);
 
   const battleView = useUIStore((state) => state.battleView);
@@ -26,4 +26,4 @@ export const BattleContainer = ({ children }: { children: React.ReactNode }) =>
       {children}
     </div>
   );
-};
+});
diff --git a/client/src/ui/containers/BlankOverlayContainer.tsx b/client/src/ui/containers/BlankOverlayContainer.tsx
index abdabe54c..d192400bd 100644
--- a/client/src/ui/containers/BlankOverlayContainer.tsx
+++ b/client/src/ui/containers/BlankOverlayContainer.tsx
@@ -1,12 +1,12 @@
 import { Transition } from "@headlessui/react";
-import React, { Fragment } from "react";
+import { Fragment, memo } from "react";
 
 type BlurOverlayContainerProps = {
   children?: React.ReactNode;
   open: boolean;
 } & React.HTMLAttributes<HTMLDivElement>;
 
-export const BlankOverlayContainer = ({ children, open }: BlurOverlayContainerProps) => {
+export const BlankOverlayContainer = memo(({ children, open }: BlurOverlayContainerProps) => {
   return (
     <Transition
       show={open}
@@ -23,4 +23,4 @@ export const BlankOverlayContainer = ({ children, open }: BlurOverlayContainerPr
       </div>
     </Transition>
   );
-};
+});
diff --git a/client/src/ui/containers/BottomMiddleContainer.tsx b/client/src/ui/containers/BottomMiddleContainer.tsx
index 9d5dcc8e8..c0cac11c7 100644
--- a/client/src/ui/containers/BottomMiddleContainer.tsx
+++ b/client/src/ui/containers/BottomMiddleContainer.tsx
@@ -1,7 +1,9 @@
-export const BottomMiddleContainer = ({ children }: { children: React.ReactNode }) => {
+import { memo } from "react";
+
+export const BottomMiddleContainer = memo(({ children }: { children: React.ReactNode }) => {
   return (
     <div className="absolute w-screen bottom-0 left-1/2 transform -translate-x-1/2 flex justify-center pointer-events-none z-20">
       {children}
     </div>
   );
-};
+});
diff --git a/client/src/ui/containers/BottomRightContainer.tsx b/client/src/ui/containers/BottomRightContainer.tsx
index a367e9945..efa5787e5 100644
--- a/client/src/ui/containers/BottomRightContainer.tsx
+++ b/client/src/ui/containers/BottomRightContainer.tsx
@@ -1,9 +1,9 @@
-import { ReactNode } from "react";
+import { ReactNode, memo } from "react";
 
 interface BottomRightContainerProps {
   children?: ReactNode;
 }
 
-export const BottomRightContainer = ({ children }: BottomRightContainerProps) => {
+export const BottomRightContainer = memo(({ children }: BottomRightContainerProps) => {
   return <div className="absolute flex flex-col bottom-0 right-0 root-container z-30 w-full md:w-auto">{children}</div>;
-};
+});
diff --git a/client/src/ui/containers/LeftMiddleContainer.tsx b/client/src/ui/containers/LeftMiddleContainer.tsx
index 4fbb608d5..96dbc0b2b 100644
--- a/client/src/ui/containers/LeftMiddleContainer.tsx
+++ b/client/src/ui/containers/LeftMiddleContainer.tsx
@@ -1,7 +1,9 @@
-const LeftMiddleContainer = ({ children }: { children: React.ReactNode }) => {
+import { memo } from "react";
+
+const LeftMiddleContainer = memo(({ children }: { children: React.ReactNode }) => {
   return (
     <div className="absolute z-20 w-auto top-14 md:top-0 h-screen left-0 flex pointer-events-none">{children}</div>
   );
-};
+});
 
 export default LeftMiddleContainer;
diff --git a/client/src/ui/containers/RightMiddleContainer.tsx b/client/src/ui/containers/RightMiddleContainer.tsx
index 77db6dd35..c101c5adb 100644
--- a/client/src/ui/containers/RightMiddleContainer.tsx
+++ b/client/src/ui/containers/RightMiddleContainer.tsx
@@ -1,5 +1,7 @@
-const RightMiddleContainer = ({ children }: { children: React.ReactNode }) => {
+import { memo } from "react";
+
+const RightMiddleContainer = memo(({ children }: { children: React.ReactNode }) => {
   return <div className="absolute z-20 w-auto right-0 flex h-screen top-0 pointer-events-none">{children}</div>;
-};
+});
 
 export default RightMiddleContainer;
diff --git a/client/src/ui/containers/TopCenterContainer.tsx b/client/src/ui/containers/TopCenterContainer.tsx
index a4e004138..269ddb518 100644
--- a/client/src/ui/containers/TopCenterContainer.tsx
+++ b/client/src/ui/containers/TopCenterContainer.tsx
@@ -1,5 +1,7 @@
-const TopCenterContainer = ({ children }: { children: React.ReactNode }) => {
+import { memo } from "react";
+
+const TopCenterContainer = memo(({ children }: { children: React.ReactNode }) => {
   return <div className="absolute w-screen top-10 flex pointer-events-none z-20">{children}</div>;
-};
+});
 
 export default TopCenterContainer;
diff --git a/client/src/ui/containers/TopLeftContainer.tsx b/client/src/ui/containers/TopLeftContainer.tsx
index 53c01524e..71dd252f4 100644
--- a/client/src/ui/containers/TopLeftContainer.tsx
+++ b/client/src/ui/containers/TopLeftContainer.tsx
@@ -1,5 +1,7 @@
-const TopLeftContainer = ({ children }: { children: React.ReactNode }) => {
+import { memo } from "react";
+
+const TopLeftContainer = memo(({ children }: { children: React.ReactNode }) => {
   return <div className="absolute top-0 left-0 pointer-events-auto z-20">{children}</div>;
-};
+});
 
 export default TopLeftContainer;
diff --git a/client/src/ui/elements/ListSelect.tsx b/client/src/ui/elements/ListSelect.tsx
index c1439d711..75c85415a 100644
--- a/client/src/ui/elements/ListSelect.tsx
+++ b/client/src/ui/elements/ListSelect.tsx
@@ -2,11 +2,13 @@ import { ReactComponent as CaretDown } from "@/assets/icons/common/caret-down-fi
 import { ReactComponent as Checkmark } from "@/assets/icons/common/checkmark.svg";
 import { Listbox, Transition } from "@headlessui/react";
 import clsx from "clsx";
-import { Fragment, ReactNode, useMemo } from "react";
+import { Fragment, ReactNode, useMemo, useRef, useState } from "react";
+import TextInput from "./TextInput";
 
 interface ListSelectOption {
   id: any;
   label: ReactNode;
+  searchText?: string;
 }
 
 type ListSelectProps = {
@@ -16,20 +18,45 @@ type ListSelectProps = {
   onChange: (value: any) => void;
   className?: string;
   style?: "default" | "black";
+  enableFilter?: boolean;
 };
 
 function ListSelect(props: ListSelectProps) {
+  const [searchInput, setSearchInput] = useState("");
+  const inputRef = useRef<HTMLInputElement>(null);
+
   const selectedOption = useMemo(
     () =>
       props.options.find((option) => option.id === props.value) ||
       props.options[0] || { id: "", label: "Select a wallet..." },
     [props.value],
   );
+
+  const filteredOptions = useMemo(() => {
+    if (!searchInput || !props.enableFilter) return props.options;
+
+    return props.options.filter((option) => {
+      const searchText = option.searchText || (typeof option.label === "string" ? option.label : "");
+      return searchText.toLowerCase().includes(searchInput.toLowerCase());
+    });
+  }, [props.options, searchInput, props.enableFilter]);
+
+  const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === "Enter") {
+      if (filteredOptions.length > 0) {
+        props.onChange(filteredOptions[0].id);
+        setSearchInput("");
+      }
+    } else {
+      e.stopPropagation();
+    }
+  };
+
   return (
     <div className={clsx("w-full", props.className, "z-100")}>
       <Listbox value={props.value} onChange={props.onChange}>
         {({ open }) => (
-          <div className="relative  ">
+          <div className="relative">
             <Listbox.Button
               className={clsx(
                 "flex items-center relative  cursor-pointer text-xs py-1 min-h-[32px] z-0 w-full bg-gold/10  hover:bg-gold/20 px-2",
@@ -56,14 +83,26 @@ function ListSelect(props: ListSelectProps) {
               leaveFrom="opacity-100"
               leaveTo="opacity-0"
             >
-              <div className="absolute top-[100%] z-50 w-min text-xs">
+              <div className="absolute top-[100%] z-50 w-full text-xs">
                 <Listbox.Options
                   className={clsx(
-                    "z-50 mt-2 w-full rounded-md py-1 max-h-72 overflow-scroll z-100 border border-gold/10 no-scrollbar",
+                    "mt-2 w-full rounded-md py-1 max-h-72 overflow-scroll z-100 border border-gold/10 no-scrollbar",
                     props.style === "black" ? "bg-brown" : " bg-brown",
                   )}
                 >
-                  {props.options.map((option) => (
+                  {props.enableFilter && (
+                    <div className="p-2">
+                      <TextInput
+                        ref={inputRef}
+                        onChange={setSearchInput}
+                        placeholder="Filter..."
+                        onKeyDown={handleKeyDown}
+                        className="w-full"
+                      />
+                    </div>
+                  )}
+
+                  {filteredOptions.map((option) => (
                     <Listbox.Option
                       key={option.id}
                       className={({ active }) =>
diff --git a/client/src/ui/layouts/World.tsx b/client/src/ui/layouts/World.tsx
index 3a2132791..5448f989e 100644
--- a/client/src/ui/layouts/World.tsx
+++ b/client/src/ui/layouts/World.tsx
@@ -3,12 +3,18 @@ import { lazy, Suspense, useEffect, useMemo, useState } from "react";
 import { Redirect } from "wouter";
 import useUIStore from "../../hooks/store/useUIStore";
 
-import { addMarketSubscription, addToSubscription, addToSubscriptionOneKeyModelbyRealmEntityId } from "@/dojo/queries";
+import {
+  debounceAddResourceArrivals,
+  debouncedAddHyperstructureSubscription,
+  debouncedAddMarketSubscription,
+  debouncedAddToSubscription,
+  debouncedAddToSubscriptionOneKey,
+} from "@/dojo/debouncedQueries";
 import { useDojo } from "@/hooks/context/DojoContext";
 import { PlayerStructure, useEntities } from "@/hooks/helpers/useEntities";
 import { useStructureEntityId } from "@/hooks/helpers/useStructureEntityId";
 import { useFetchBlockchainData } from "@/hooks/store/useBlockchainStore";
-import { useWorldStore } from "@/hooks/store/useWorldLoading";
+import { LoadingStateKey } from "@/hooks/store/useWorldLoading";
 import { ADMIN_BANK_ENTITY_ID } from "@bibliothecadao/eternum";
 import { getComponentValue } from "@dojoengine/recs";
 import { getEntityIdFromKeys } from "@dojoengine/utils";
@@ -89,10 +95,8 @@ export const World = ({ backgroundImage }: { backgroundImage: string }) => {
   const [subscriptions, setSubscriptions] = useState<{ [entity: string]: boolean }>({});
   const showBlankOverlay = useUIStore((state) => state.showBlankOverlay);
   const isLoadingScreenEnabled = useUIStore((state) => state.isLoadingScreenEnabled);
-
   const showModal = useUIStore((state) => state.showModal);
   const modalContent = useUIStore((state) => state.modalContent);
-
   const battleView = useUIStore((state) => state.battleView);
 
   // Setup hooks
@@ -100,10 +104,7 @@ export const World = ({ backgroundImage }: { backgroundImage: string }) => {
   useStructureEntityId();
 
   // We could optimise this deeper....
-
-  const worldLoading = useWorldStore((state) => state.isWorldLoading);
-  const setWorldLoading = useWorldStore((state) => state.setWorldLoading);
-  const setMarketLoading = useWorldStore((state) => state.setMarketLoading);
+  const setLoading = useUIStore((state) => state.setLoading);
 
   const dojo = useDojo();
   const structureEntityId = useUIStore((state) => state.structureEntityId);
@@ -131,7 +132,6 @@ export const World = ({ backgroundImage }: { backgroundImage: string }) => {
       getEntityIdFromKeys([BigInt(structureEntityId)]),
     );
 
-    setWorldLoading(true);
     setSubscriptions((prev) => ({
       ...prev,
       [structureEntityId.toString()]: true,
@@ -139,21 +139,21 @@ export const World = ({ backgroundImage }: { backgroundImage: string }) => {
       ...Object.fromEntries(filteredStructures.map((structure) => [structure.entity_id.toString(), true])),
     }));
 
+    setLoading(LoadingStateKey.SelectedStructure, true);
     const fetch = async () => {
       console.log("AddToSubscriptionStart - 1");
       try {
         await Promise.all([
-          addToSubscription(
+          debouncedAddToSubscription(
             dojo.network.toriiClient,
             dojo.network.contractComponents as any,
             [structureEntityId.toString()],
             [{ x: position?.x || 0, y: position?.y || 0 }],
+            () => setLoading(LoadingStateKey.SelectedStructure, false),
           ),
         ]);
       } catch (error) {
         console.error("Fetch failed", error);
-      } finally {
-        setWorldLoading(false);
       }
     };
 
@@ -161,40 +161,111 @@ export const World = ({ backgroundImage }: { backgroundImage: string }) => {
   }, [structureEntityId]);
 
   useEffect(() => {
-    try {
-      setWorldLoading(true);
-      console.log("AddToSubscriptionStart - 2");
-      addToSubscription(
-        dojo.network.toriiClient,
-        dojo.network.contractComponents as any,
-        [...filteredStructures.map((structure) => structure.entity_id.toString())],
-        [...filteredStructures.map((structure) => ({ x: structure.position.x, y: structure.position.y }))],
-      );
-      addToSubscriptionOneKeyModelbyRealmEntityId(dojo.network.toriiClient, dojo.network.contractComponents as any, [
-        ...filteredStructures.map((structure) => structure.entity_id.toString()),
-      ]);
-    } catch (error) {
-      console.error("Fetch failed", error);
-    } finally {
-      setWorldLoading(false);
-    }
+    const fetch = async () => {
+      setLoading(LoadingStateKey.PlayerStructuresOneKey, true);
+      setLoading(LoadingStateKey.PlayerStructuresTwoKey, true);
+      setLoading(LoadingStateKey.Arrivals, true);
+
+      const isSyncing = true;
+
+      try {
+        console.log("AddToSubscriptionStart - 2");
+        await Promise.all([
+          debouncedAddToSubscription(
+            dojo.network.toriiClient,
+            dojo.network.contractComponents as any,
+            [...filteredStructures.map((structure) => structure.entity_id.toString())],
+            [...filteredStructures.map((structure) => ({ x: structure.position.x, y: structure.position.y }))],
+            () => setLoading(LoadingStateKey.PlayerStructuresOneKey, false),
+          ),
+          debouncedAddToSubscriptionOneKey(
+            dojo.network.toriiClient,
+            dojo.network.contractComponents as any,
+            [...filteredStructures.map((structure) => structure.entity_id.toString())],
+            () => setLoading(LoadingStateKey.PlayerStructuresTwoKey, false),
+          ),
+        ]);
+
+        await debounceAddResourceArrivals(
+          dojo.network.toriiClient,
+          dojo.network.contractComponents as any,
+          [...structures.map((structure) => structure.entity_id)],
+          () => setLoading(LoadingStateKey.Arrivals, false),
+        );
+      } catch (error) {
+        console.error("Fetch failed", error);
+      }
+    };
+
+    fetch();
   }, [structures.length]);
 
   useEffect(() => {
-    try {
-      setMarketLoading(true);
-      console.log("AddToSubscriptionStart - 3");
-      addToSubscription(dojo.network.toriiClient, dojo.network.contractComponents as any, [
-        ADMIN_BANK_ENTITY_ID.toString(),
-      ]);
-      addMarketSubscription(dojo.network.toriiClient, dojo.network.contractComponents as any);
-    } catch (error) {
-      console.error("Fetch failed", error);
-    } finally {
-      setMarketLoading(false);
-    }
+    const fetch = async () => {
+      try {
+        setLoading(LoadingStateKey.Market, true);
+        setLoading(LoadingStateKey.Bank, true);
+        console.log("AddToSubscriptionStart - 3");
+        await Promise.all([
+          debouncedAddToSubscription(
+            dojo.network.toriiClient,
+            dojo.network.contractComponents as any,
+            [ADMIN_BANK_ENTITY_ID.toString()],
+            [],
+            () => setLoading(LoadingStateKey.Bank, false),
+          ),
+          debouncedAddMarketSubscription(dojo.network.toriiClient, dojo.network.contractComponents as any, () =>
+            setLoading(LoadingStateKey.Market, false),
+          ),
+        ]);
+      } catch (error) {
+        console.error("Fetch failed", error);
+      } finally {
+        // Ensure loading states are reset even if there's an error
+        setLoading(LoadingStateKey.Bank, false);
+        setLoading(LoadingStateKey.Market, false);
+      }
+    };
+
+    fetch();
   }, []);
 
+  useEffect(() => {
+    const fetch = async () => {
+      try {
+        setLoading(LoadingStateKey.Hyperstructure, true);
+        console.log("AddToSubscriptionStart - 4");
+        await Promise.all([
+          debouncedAddHyperstructureSubscription(dojo.network.toriiClient, dojo.network.contractComponents as any, () =>
+            setLoading(LoadingStateKey.Hyperstructure, false),
+          ),
+        ]);
+      } catch (error) {
+        console.error("Fetch failed", error);
+      } finally {
+        // Ensure loading states are reset even if there's an error
+        setLoading(LoadingStateKey.Hyperstructure, false);
+      }
+    };
+
+    fetch();
+  }, []);
+
+  const battleViewContent = useMemo(
+    () => (
+      <div>
+        <Suspense fallback={<LoadingOroborus loading={true} />}>
+          {battleView && (
+            <BattleContainer>
+              <BattleView />
+            </BattleContainer>
+          )}
+        </Suspense>
+      </div>
+    ),
+    [battleView],
+  );
+
   return (
     <div
       onClick={(e) => {
@@ -228,9 +299,7 @@ export const World = ({ backgroundImage }: { backgroundImage: string }) => {
           </>
         )}
 
-        <BattleContainer>
-          <BattleView />
-        </BattleContainer>
+        {battleViewContent}
 
         <div className={`${battleView ? "opacity-0 pointer-events-none" : ""}`}>
           <LeftMiddleContainer>
@@ -257,7 +326,7 @@ export const World = ({ backgroundImage }: { backgroundImage: string }) => {
           )}
 
           <TopLeftContainer>
-            <TopLeftNavigation />
+            <TopLeftNavigation structures={structures} />
           </TopLeftContainer>
         </div>
 
diff --git a/client/src/ui/modules/military/battle-view/BattleView.tsx b/client/src/ui/modules/military/battle-view/BattleView.tsx
index d9985125e..2c38e8e80 100644
--- a/client/src/ui/modules/military/battle-view/BattleView.tsx
+++ b/client/src/ui/modules/military/battle-view/BattleView.tsx
@@ -6,10 +6,10 @@ import { Structure, useStructureByEntityId, useStructureByPosition } from "@/hoo
 import useUIStore from "@/hooks/store/useUIStore";
 import useNextBlockTimestamp from "@/hooks/useNextBlockTimestamp";
 import { BattleSide } from "@bibliothecadao/eternum";
-import { useMemo } from "react";
+import { memo, useMemo } from "react";
 import { Battle } from "./Battle";
 
-export const BattleView = () => {
+export const BattleView = memo(() => {
   const dojo = useDojo();
   const getStructure = useStructureByPosition();
   const armiesByBattleId = getArmiesByBattleId();
@@ -148,4 +148,4 @@ export const BattleView = () => {
       structure={structure as Structure}
     />
   );
-};
+});
diff --git a/client/src/ui/modules/navigation/LeftNavigationModule.tsx b/client/src/ui/modules/navigation/LeftNavigationModule.tsx
index 99ee80bf3..2d0710713 100644
--- a/client/src/ui/modules/navigation/LeftNavigationModule.tsx
+++ b/client/src/ui/modules/navigation/LeftNavigationModule.tsx
@@ -126,7 +126,7 @@ export const LeftNavigationModule = memo(() => {
         name: MenuEnum.construction,
         button: (
           <CircleButton
-            // disabled={!structureIsMine || !isRealm}
+            disabled={!structureIsMine || !isRealm}
             className="construction-selector"
             image={BuildingThumbs.construction}
             tooltipLocation="top"
diff --git a/client/src/ui/modules/navigation/QuestMenu.tsx b/client/src/ui/modules/navigation/QuestMenu.tsx
index 2b86307ff..bc34b4c72 100644
--- a/client/src/ui/modules/navigation/QuestMenu.tsx
+++ b/client/src/ui/modules/navigation/QuestMenu.tsx
@@ -2,7 +2,6 @@ import { useDojo } from "@/hooks/context/DojoContext";
 import { Prize, QuestStatus, useQuests, useUnclaimedQuestsCount } from "@/hooks/helpers/useQuests";
 import { useRealm } from "@/hooks/helpers/useRealm";
 import useUIStore from "@/hooks/store/useUIStore";
-import { useWorldStore } from "@/hooks/store/useWorldLoading";
 import { useStartingTutorial } from "@/hooks/use-starting-tutorial";
 import { questSteps, useTutorial } from "@/hooks/use-tutorial";
 import Button from "@/ui/elements/Button";
@@ -19,7 +18,7 @@ export const QuestsMenu = memo(() => {
     },
   } = useDojo();
 
-  const worldLoading = useWorldStore((state) => state.isWorldLoading);
+  const questsLoaded = useUIStore((state) => state.loadingStates.playerStructuresTwoKey);
 
   useStartingTutorial();
 
@@ -34,7 +33,6 @@ export const QuestsMenu = memo(() => {
 
   const { handleStart } = useTutorial(questSteps.get(currentQuest?.id || QuestType.Settle));
 
-  const isWorldLoading = useWorldStore((state) => state.isWorldLoading);
   const { unclaimedQuestsCount } = useUnclaimedQuestsCount();
 
   const [isLoading, setIsLoading] = useState(false);
@@ -81,7 +79,7 @@ export const QuestsMenu = memo(() => {
   };
 
   const handleClaimMouseEnter = (e: React.MouseEvent<HTMLButtonElement>) => {
-    if (worldLoading) return;
+    if (questsLoaded) return;
 
     const rect = e.currentTarget.getBoundingClientRect();
     const tooltipWidth = 300;
@@ -106,11 +104,11 @@ export const QuestsMenu = memo(() => {
 
   return (
     unclaimedQuestsCount > 0 &&
-    !isWorldLoading && (
+    !questsLoaded && (
       <div className="absolute right-0 px-4 top-full mt-2">
         <div
           className={clsx("flex gap-2 bg-brown/90 border border-gold/30 rounded-full px-4 h-10 md:h-12 py-2", {
-            "opacity-50 pointer-events-none": worldLoading,
+            "opacity-50 pointer-events-none": questsLoaded,
           })}
         >
           <Button
@@ -118,14 +116,14 @@ export const QuestsMenu = memo(() => {
             isLoading={isLoading}
             className={clsx("claim-selector text-sm !font-bold capitalize", {
               "!border-gold/70 !text-brown !bg-gold hover:!bg-gold/70 animate-pulse hover:animate-none":
-                currentQuest?.status === QuestStatus.Completed && !worldLoading,
+                currentQuest?.status === QuestStatus.Completed && !questsLoaded,
             })}
             onClick={handleClaimQuest}
             onMouseEnter={handleClaimMouseEnter}
-            onMouseLeave={() => !worldLoading && setTooltip(null)}
-            disabled={currentQuest?.status !== QuestStatus.Completed || worldLoading}
+            onMouseLeave={() => !questsLoaded && setTooltip(null)}
+            disabled={currentQuest?.status !== QuestStatus.Completed || questsLoaded}
           >
-            {worldLoading ? "Loading..." : "Claim"}
+            {questsLoaded ? "Loading..." : "Claim"}
           </Button>
 
           <div className="h-full flex items-center">
@@ -136,19 +134,19 @@ export const QuestsMenu = memo(() => {
             onClick={() => handleStart()}
             variant="outline"
             disabled={
-              (currentQuest?.status === QuestStatus.Completed && currentQuest.id !== QuestType.Settle) || worldLoading
+              (currentQuest?.status === QuestStatus.Completed && currentQuest.id !== QuestType.Settle) || questsLoaded
             }
             className={clsx("tutorial-selector relative text-sm capitalize", {
               "!border-gold/70 !text-brown !bg-gold hover:!bg-gold/70 animate-pulse hover:animate-none":
-                currentQuest?.status !== QuestStatus.Completed && !worldLoading,
+                currentQuest?.status !== QuestStatus.Completed && !questsLoaded,
             })}
           >
-            <span className="font-semibold">{worldLoading ? "Loading..." : currentQuest?.name}</span>
+            <span className="font-semibold">{questsLoaded ? "Loading..." : currentQuest?.name}</span>
             <div
               className={clsx(
                 "absolute rounded-full border border-green/30 bg-green/90 text-brown px-1.5 md:px-2 text-[0.6rem] md:text-xxs z-[100] font-bold -top-1 -right-1",
                 {
-                  "animate-bounce": !worldLoading,
+                  "animate-bounce": !questsLoaded,
                 },
               )}
             >
@@ -166,25 +164,25 @@ export const QuestsMenu = memo(() => {
                 className="text-sm font-semibold capitalize"
                 onClick={handleClaimAllQuests}
                 variant="red"
-                disabled={worldLoading}
+                disabled={questsLoaded}
               >
-                {worldLoading ? "Loading..." : "Skip All Quests"}
+                {questsLoaded ? "Loading..." : "Skip All Quests"}
               </Button>
               <Button
                 className="text-sm font-semibold capitalize"
                 onClick={handleClaimQuest}
                 variant="red"
-                disabled={worldLoading}
+                disabled={questsLoaded}
               >
-                {worldLoading ? "Loading..." : "Confirm"}
+                {questsLoaded ? "Loading..." : "Confirm"}
               </Button>
               <Button
                 variant="primary"
                 className="text-sm font-semibold capitalize"
                 onClick={() => setSkipQuest(false)}
-                disabled={worldLoading}
+                disabled={questsLoaded}
               >
-                {worldLoading ? "Loading..." : "Cancel"}
+                {questsLoaded ? "Loading..." : "Cancel"}
               </Button>
             </div>
           ) : (
@@ -192,9 +190,9 @@ export const QuestsMenu = memo(() => {
               variant="primary"
               className="text-sm font-semibold capitalize w-6"
               onClick={() => setSkipQuest(true)}
-              disabled={worldLoading}
+              disabled={questsLoaded}
             >
-              {worldLoading ? "..." : "Skip"}
+              {questsLoaded ? "..." : "Skip"}
             </Button>
           )}
         </div>
diff --git a/client/src/ui/modules/navigation/TopLeftNavigation.tsx b/client/src/ui/modules/navigation/TopLeftNavigation.tsx
index ed6befec1..ebab40085 100644
--- a/client/src/ui/modules/navigation/TopLeftNavigation.tsx
+++ b/client/src/ui/modules/navigation/TopLeftNavigation.tsx
@@ -1,6 +1,6 @@
 import { configManager } from "@/dojo/setup";
 import { useDojo } from "@/hooks/context/DojoContext";
-import { useEntities, useEntitiesUtils } from "@/hooks/helpers/useEntities";
+import { PlayerStructure, useEntitiesUtils } from "@/hooks/helpers/useEntities";
 import { useQuery } from "@/hooks/helpers/useQuery";
 import useUIStore from "@/hooks/store/useUIStore";
 import useNextBlockTimestamp from "@/hooks/useNextBlockTimestamp";
@@ -92,13 +92,11 @@ const WorkersHutTooltipContent = () => {
   );
 };
 
-export const TopLeftNavigation = memo(() => {
+export const TopLeftNavigation = memo(({ structures }: { structures: PlayerStructure[] }) => {
   const { setup } = useDojo();
 
   const { isMapView, handleUrlChange, hexPosition } = useQuery();
-  const { playerStructures } = useEntities();
   const { getEntityInfo } = useEntitiesUtils();
-  const structures = playerStructures();
 
   const isSpectatorMode = useUIStore((state) => state.isSpectatorMode);
   const structureEntityId = useUIStore((state) => state.structureEntityId);
diff --git a/client/src/ui/modules/navigation/TopNavigation.tsx b/client/src/ui/modules/navigation/TopNavigation.tsx
index b8ebb09ab..551b1137c 100644
--- a/client/src/ui/modules/navigation/TopNavigation.tsx
+++ b/client/src/ui/modules/navigation/TopNavigation.tsx
@@ -1,5 +1,4 @@
 import { useGetAllPlayers } from "@/hooks/helpers/use-get-all-players";
-
 import { memo } from "react";
 import { Rewards } from "../rewards/Rewards";
 import { SettingsWindow } from "../settings/Settings";
@@ -7,12 +6,11 @@ import { Social } from "../social/Social";
 
 export const TopMiddleNavigation = memo(() => {
   const getPlayers = useGetAllPlayers();
-  const players = getPlayers();
 
   return (
     <>
       <div className="pointer-events-auto">
-        <Social players={players} />
+        <Social getPlayers={getPlayers} />
         <Rewards />
         <SettingsWindow />
       </div>
diff --git a/client/src/ui/modules/settings/Settings.tsx b/client/src/ui/modules/settings/Settings.tsx
index 700b8e54d..90f532b42 100644
--- a/client/src/ui/modules/settings/Settings.tsx
+++ b/client/src/ui/modules/settings/Settings.tsx
@@ -1,8 +1,8 @@
+import { ReactComponent as Controller } from "@/assets/icons/Controller.svg";
 import { ReactComponent as Copy } from "@/assets/icons/common/copy.svg";
 import { ReactComponent as Next } from "@/assets/icons/common/fast-forward.svg";
 import { ReactComponent as Muted } from "@/assets/icons/common/muted.svg";
 import { ReactComponent as Unmuted } from "@/assets/icons/common/unmuted.svg";
-import { ReactComponent as Controller } from "@/assets/icons/Controller.svg";
 import { ReactComponent as DojoMark } from "@/assets/icons/dojo-mark-full-dark.svg";
 import { ReactComponent as RealmsWorld } from "@/assets/icons/rw-logo.svg";
 import { useDojo } from "@/hooks/context/DojoContext";
@@ -18,7 +18,7 @@ import Button from "@/ui/elements/Button";
 import { Checkbox } from "@/ui/elements/Checkbox";
 import { Headline } from "@/ui/elements/Headline";
 import { RangeInput } from "@/ui/elements/RangeInput";
-import { addressToNumber, displayAddress } from "@/ui/utils/utils";
+import { addressToNumber, currencyIntlFormat, displayAddress } from "@/ui/utils/utils";
 import { ContractAddress } from "@bibliothecadao/eternum";
 import { useEffect, useRef, useState } from "react";
 import { toast } from "sonner";
@@ -42,6 +42,16 @@ export const SettingsWindow = () => {
   const isSoundOn = useUIStore((state) => state.isSoundOn);
   const toggleSound = useUIStore((state) => state.toggleSound);
 
+  const getCurrentDonkeyWeightMinimum = () => {
+    return Number(localStorage.getItem("WEIGHT_MINIMUM") || 0);
+  };
+
+  const [donkeyWeightLimit, setDonkeyWeightLimit] = useState(getCurrentDonkeyWeightMinimum());
+
+  useEffect(() => {
+    localStorage.setItem("WEIGHT_MINIMUM", donkeyWeightLimit.toString());
+  }, [donkeyWeightLimit]);
+
   const { toggleFullScreen, isFullScreen } = useScreenOrientation();
   const [fullScreen, setFullScreen] = useState<boolean>(isFullScreen());
 
@@ -61,7 +71,7 @@ export const SettingsWindow = () => {
 
   const isOpen = useUIStore((state) => state.isPopupOpen(settings));
 
-  const GRAPHICS_SETTING = localStorage.getItem("GRAPHICS_SETTING") as GraphicsSettings || GraphicsSettings.HIGH;
+  const GRAPHICS_SETTING = (localStorage.getItem("GRAPHICS_SETTING") as GraphicsSettings) || GraphicsSettings.HIGH;
 
   return (
     <OSWindow onClick={() => togglePopup(settings)} show={isOpen} title={settings}>
@@ -145,6 +155,18 @@ export const SettingsWindow = () => {
 
         <RangeInput value={musicLevel} fromTitle="Mute" onChange={setMusicLevel} title="Music" />
         <RangeInput value={effectsLevel} fromTitle="Mute" onChange={setEffectsLevel} title="Effects" />
+
+        <Headline>Donkey Settings</Headline>
+        <RangeInput
+          value={donkeyWeightLimit}
+          min={0}
+          max={100000}
+          fromTitle="0"
+          toTitle={currencyIntlFormat(100000)}
+          onChange={setDonkeyWeightLimit}
+          title={`Minimum Weight: ${donkeyWeightLimit} kg`}
+        />
+
         <Button onClick={() => setShowSettings(false)} variant="outline" className="text-xxs !py-1 !px-2 mr-auto">
           Done
         </Button>
diff --git a/client/src/ui/modules/social/Social.tsx b/client/src/ui/modules/social/Social.tsx
index 92178c677..a38abdb77 100644
--- a/client/src/ui/modules/social/Social.tsx
+++ b/client/src/ui/modules/social/Social.tsx
@@ -1,5 +1,5 @@
 import { useDojo } from "@/hooks/context/DojoContext";
-import { useHyperstructureData } from "@/hooks/store/useLeaderBoardStore";
+import { useHyperstructureData, useLeaderBoardStore } from "@/hooks/store/useLeaderBoardStore";
 import useUIStore from "@/hooks/store/useUIStore";
 import { HintSection } from "@/ui/components/hints/HintModal";
 import { social } from "@/ui/components/navigation/Config";
@@ -12,11 +12,11 @@ import { Tabs } from "@/ui/elements/tab";
 import { ContractAddress, ID, Player } from "@bibliothecadao/eternum";
 import { useEntityQuery } from "@dojoengine/react";
 import { Has } from "@dojoengine/recs";
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { EndSeasonButton } from "./EndSeasonButton";
 import { PlayerId } from "./PlayerId";
 
-export const Social = ({ players }: { players: Player[] }) => {
+export const Social = ({ getPlayers }: { getPlayers: () => Player[] }) => {
   const {
     setup: {
       components: {
@@ -26,7 +26,7 @@ export const Social = ({ players }: { players: Player[] }) => {
   } = useDojo();
   const [selectedTab, setSelectedTab] = useState(0);
   const [isExpanded, setIsExpanded] = useState(false);
-
+  const [isLoading, setIsLoading] = useState(false);
   const [selectedGuild, setSelectedGuild] = useState<ID>(0);
   const [selectedPlayer, setSelectedPlayer] = useState<ContractAddress>(0n);
 
@@ -35,8 +35,21 @@ export const Social = ({ players }: { players: Player[] }) => {
 
   const gameEnded = useEntityQuery([Has(GameEnded)]);
 
+  const [players, setPlayers] = useState(() => getPlayers());
+  const playersByRank = useLeaderBoardStore((state) => state.playersByRank);
+
   const updateLeaderboard = useHyperstructureData();
 
+  const handleUpdatePoints = () => {
+    setIsLoading(true);
+    updateLeaderboard();
+  };
+
+  useEffect(() => {
+    setPlayers(getPlayers());
+    setIsLoading(false);
+  }, [playersByRank]);
+
   const viewGuildMembers = (guildEntityId: ID) => {
     if (selectedGuild === guildEntityId) {
       setSelectedPlayer(0n);
@@ -112,7 +125,7 @@ export const Social = ({ players }: { players: Player[] }) => {
 
         <div className="flex justify-center gap-8">
           {gameEnded.length === 0 && <EndSeasonButton />}
-          <Button variant="secondary" onClick={updateLeaderboard}>
+          <Button isLoading={isLoading} variant="secondary" onClick={handleUpdatePoints}>
             Update Points
           </Button>
         </div>
diff --git a/client/src/ui/modules/world-structures/WorldStructuresMenu.tsx b/client/src/ui/modules/world-structures/WorldStructuresMenu.tsx
index 7473c53e0..2e55caf1e 100644
--- a/client/src/ui/modules/world-structures/WorldStructuresMenu.tsx
+++ b/client/src/ui/modules/world-structures/WorldStructuresMenu.tsx
@@ -7,7 +7,6 @@ import { useFragmentMines } from "@/hooks/helpers/useFragmentMines";
 import { useGuilds } from "@/hooks/helpers/useGuilds";
 import { useHyperstructureProgress, useHyperstructures } from "@/hooks/helpers/useHyperstructures";
 import { useResourceBalance } from "@/hooks/helpers/useResources";
-import { useWorldStore } from "@/hooks/store/useWorldLoading";
 import { FragmentMinePanel } from "@/ui/components/fragmentMines/FragmentMinePanel";
 import { HintSection } from "@/ui/components/hints/HintModal";
 import { DisplayedAccess, HyperstructurePanel } from "@/ui/components/hyperstructures/HyperstructurePanel";
@@ -19,39 +18,15 @@ import { HintModalButton } from "@/ui/elements/HintModalButton";
 import { ResourceIcon } from "@/ui/elements/ResourceIcon";
 import { currencyFormat, currencyIntlFormat, divideByPrecision } from "@/ui/utils/utils";
 import { BattleSide, ContractAddress, ID, ResourcesIds, findResourceById } from "@bibliothecadao/eternum";
-import { Metadata } from "@dojoengine/recs";
-import { S } from "@dojoengine/recs/dist/types-3444e4c1";
-import { getEntities } from "@dojoengine/state";
-import { ToriiClient } from "@dojoengine/torii-wasm";
 import { ArrowRight } from "lucide-react";
-import { Component, useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useMemo, useState } from "react";
 import { Tabs } from "../../elements/tab";
 
 export const WorldStructuresMenu = ({ className }: { className?: string }) => {
   const {
     account: { account },
-    network: { toriiClient, contractComponents },
   } = useDojo();
 
-  const isStructuresLoading = useWorldStore((state) => state.isStructuresLoading);
-  const setStructuresLoading = useWorldStore((state) => state.setStructuresLoading);
-
-  useEffect(() => {
-    const fetchData = async () => {
-      try {
-        await fetchHyperstructureData(
-          toriiClient,
-          contractComponents as any,
-          isStructuresLoading,
-          setStructuresLoading,
-        );
-      } catch (error) {
-        console.error("Failed to fetch hyperstructure data:", error);
-      }
-    };
-    fetchData();
-  }, [toriiClient, contractComponents]);
-
   const [selectedTab, setSelectedTab] = useState(0);
   const [showOnlyMine, setShowOnlyMine] = useState(false);
 
@@ -142,14 +117,6 @@ export const WorldStructuresMenu = ({ className }: { className?: string }) => {
     [selectedTab, hyperstructures, fragmentMines, showOnlyMine, account.address, myHyperstructures],
   );
 
-  if (isStructuresLoading) {
-    return (
-      <div className="flex items-center justify-center h-full">
-        <div className="text-gold">Loading structures...</div>
-      </div>
-    );
-  }
-
   return (
     <>
       <HintModalButton className="absolute top-1 right-1" section={HintSection.WorldStructures} />
@@ -342,47 +309,3 @@ const EntityHeader = ({ entity }: { entity: any }) => {
     </div>
   );
 };
-
-const fetchHyperstructureData = async (
-  client: ToriiClient,
-  components: Component<S, Metadata, undefined>[],
-  isStructuresLoading: boolean,
-  setStructuresLoading: (loading: boolean) => void,
-) => {
-  if (!isStructuresLoading) {
-    return;
-  }
-
-  console.log("Fetching hyperstructure data");
-  await getEntities(
-    client,
-    {
-      Composite: {
-        operator: "Or",
-        clauses: [
-          {
-            Keys: {
-              keys: [undefined, undefined],
-              pattern_matching: "VariableLen",
-              models: ["s0_eternum-Contribution"],
-            },
-          },
-          {
-            Keys: {
-              keys: [undefined, undefined, undefined],
-              pattern_matching: "VariableLen",
-              models: ["s0_eternum-Epoch", "s0_eternum-Progress"],
-            },
-          },
-        ],
-      },
-    },
-    components as any,
-    [],
-    [],
-    40_000,
-    false,
-  ).finally(() => {
-    setStructuresLoading(false);
-  });
-};
diff --git a/client/src/ui/utils/utils.tsx b/client/src/ui/utils/utils.tsx
index e565ab35e..69b08240b 100644
--- a/client/src/ui/utils/utils.tsx
+++ b/client/src/ui/utils/utils.tsx
@@ -530,3 +530,7 @@ export const calculateDonkeysNeeded = (orderWeight: number): number => {
 
   return Math.ceil(divideByPrecision(orderWeight) / donkeyCapacityGrams);
 };
+
+export const normalizeDiacriticalMarks = (str: string) => {
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+};