diff --git a/src/components/DaoCreator/formComponents/AzoriusGovernance.tsx b/src/components/DaoCreator/formComponents/AzoriusGovernance.tsx
index c7acda7f76..81a593907f 100644
--- a/src/components/DaoCreator/formComponents/AzoriusGovernance.tsx
+++ b/src/components/DaoCreator/formComponents/AzoriusGovernance.tsx
@@ -25,16 +25,12 @@ import { DAOCreateMode } from './EstablishEssentials';
 export function AzoriusGovernance(props: ICreationStepProps) {
   const { values, setFieldValue, isSubmitting, transactionPending, isSubDAO, mode } = props;
 
-  const {
-    safe,
-    nodeHierarchy: { parentAddress },
-    fractalModules,
-  } = useDaoInfoStore();
+  const { safe, subgraphInfo, modules } = useDaoInfoStore();
 
-  const fractalModule = useMemo(
-    () => fractalModules.find(_module => _module.moduleType === FractalModuleType.FRACTAL),
-    [fractalModules],
-  );
+  const fractalModule = useMemo(() => {
+    if (!modules) return null;
+    return modules.find(_module => _module.moduleType === FractalModuleType.FRACTAL);
+  }, [modules]);
 
   const [showCustomNonce, setShowCustomNonce] = useState<boolean>();
   const { t } = useTranslation(['daoCreate', 'common']);
@@ -189,7 +185,7 @@ export function AzoriusGovernance(props: ICreationStepProps) {
           </Alert>
         </Flex>
       </StepWrapper>
-      {!!parentAddress && (
+      {!!subgraphInfo?.parentAddress && (
         <Box
           padding="1.5rem"
           bg="neutral-2"
diff --git a/src/components/DaoCreator/formComponents/EstablishEssentials.tsx b/src/components/DaoCreator/formComponents/EstablishEssentials.tsx
index 042d356b4c..d06ad26123 100644
--- a/src/components/DaoCreator/formComponents/EstablishEssentials.tsx
+++ b/src/components/DaoCreator/formComponents/EstablishEssentials.tsx
@@ -24,27 +24,38 @@ export function EstablishEssentials(props: ICreationStepProps) {
   const { t } = useTranslation(['daoCreate', 'common']);
   const { values, setFieldValue, isSubmitting, transactionPending, isSubDAO, errors, mode } = props;
 
-  const { daoName, daoSnapshotENS, safe } = useDaoInfoStore();
+  const { subgraphInfo, safe } = useDaoInfoStore();
 
   const isEdit = mode === DAOCreateMode.EDIT;
 
   const safeAddress = safe?.address;
 
   useEffect(() => {
-    if (isEdit) {
-      setFieldValue('essentials.daoName', daoName, false);
-      if (safeAddress && createAccountSubstring(safeAddress) !== daoName) {
+    if (isEdit && subgraphInfo) {
+      setFieldValue('essentials.daoName', subgraphInfo.daoName, false);
+      if (safeAddress && createAccountSubstring(safeAddress) !== subgraphInfo.daoName) {
         // Pre-fill the snapshot URL form field when editing
-        setFieldValue('essentials.snapshotENS', daoSnapshotENS || '', false);
+        setFieldValue('essentials.snapshotENS', subgraphInfo.daoSnapshotENS || '', false);
       }
     }
-  }, [setFieldValue, mode, daoName, daoSnapshotENS, isEdit, safeAddress]);
+  }, [
+    setFieldValue,
+    mode,
+    subgraphInfo?.daoName,
+    subgraphInfo?.daoSnapshotENS,
+    isEdit,
+    safeAddress,
+    subgraphInfo,
+  ]);
 
   const daoNameDisabled =
-    isEdit && !!daoName && !!safeAddress && createAccountSubstring(safeAddress) !== daoName;
+    isEdit &&
+    !!subgraphInfo?.daoName &&
+    !!safeAddress &&
+    createAccountSubstring(safeAddress) !== subgraphInfo?.daoName;
 
   // If in governance edit mode and snapshot URL is already set, disable the field
-  const snapshotENSDisabled = isEdit && !!daoSnapshotENS;
+  const snapshotENSDisabled = isEdit && !!subgraphInfo?.daoSnapshotENS;
 
   const handleGovernanceChange = (value: string) => {
     if (value === GovernanceType.AZORIUS_ERC20) {
diff --git a/src/components/DaoDashboard/Info/ParentLink.tsx b/src/components/DaoDashboard/Info/ParentLink.tsx
index b51610977d..0adf1499dd 100644
--- a/src/components/DaoDashboard/Info/ParentLink.tsx
+++ b/src/components/DaoDashboard/Info/ParentLink.tsx
@@ -9,11 +9,11 @@ import { useDaoInfoStore } from '../../../store/daoInfo/useDaoInfoStore';
  * Displays a link to the current DAO's parent, if it has one.
  */
 export function ParentLink() {
-  const { nodeHierarchy } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
   const { addressPrefix } = useNetworkConfig();
   const { t } = useTranslation('breadcrumbs');
 
-  if (!nodeHierarchy.parentAddress) {
+  if (!subgraphInfo?.parentAddress) {
     return null;
   }
 
@@ -21,7 +21,7 @@ export function ParentLink() {
     <Link
       color="celery-0"
       _hover={{ textDecoration: 'none', color: 'celery--6' }}
-      to={DAO_ROUTES.dao.relative(addressPrefix, nodeHierarchy.parentAddress)}
+      to={DAO_ROUTES.dao.relative(addressPrefix, subgraphInfo.parentAddress)}
       marginBottom="1rem"
       as={RouterLink}
       width="fit-content"
diff --git a/src/components/DaoHierarchy/DaoHierarchyNode.tsx b/src/components/DaoHierarchy/DaoHierarchyNode.tsx
index cb5ee5df78..cb393932d6 100644
--- a/src/components/DaoHierarchy/DaoHierarchyNode.tsx
+++ b/src/components/DaoHierarchy/DaoHierarchyNode.tsx
@@ -1,37 +1,27 @@
-import { Center, Flex, Icon, Link } from '@chakra-ui/react';
+import { useLazyQuery } from '@apollo/client';
+import { Center, Flex, Icon, Link, Text } from '@chakra-ui/react';
+import { abis } from '@fractal-framework/fractal-contracts';
 import { ArrowElbowDownRight } from '@phosphor-icons/react';
-import { useEffect, useState } from 'react';
+import { useCallback, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
 import { Link as RouterLink } from 'react-router-dom';
-import { Address } from 'viem';
-import { useChainId } from 'wagmi';
+import { Address, getContract, zeroAddress } from 'viem';
+import { useChainId, usePublicClient } from 'wagmi';
+import { DAOQueryDocument } from '../../../.graphclient';
+import { SENTINEL_ADDRESS } from '../../constants/common';
 import { DAO_ROUTES } from '../../constants/routes';
-import { useLoadDAONode } from '../../hooks/DAO/loaders/useLoadDAONode';
+import { useDecentModules } from '../../hooks/DAO/loaders/useDecentModules';
 import { CacheKeys } from '../../hooks/utils/cache/cacheDefaults';
 import { setValue, getValue } from '../../hooks/utils/cache/useLocalStorage';
+import { useAddressContractType } from '../../hooks/utils/useAddressContractType';
+import { useSafeAPI } from '../../providers/App/hooks/useSafeAPI';
 import { useNetworkConfig } from '../../providers/NetworkConfig/NetworkConfigProvider';
 import { useDaoInfoStore } from '../../store/daoInfo/useDaoInfoStore';
-import { DaoHierarchyInfo, DaoInfo, WithError } from '../../types';
+import { DaoHierarchyInfo, DaoHierarchyStrategyType, DecentModule } from '../../types';
+import { getAzoriusModuleFromModules } from '../../utils';
 import { DAONodeInfoCard, NODE_HEIGHT_REM } from '../ui/cards/DAONodeInfoCard';
 import { BarLoader } from '../ui/loaders/BarLoader';
 
-function transformNode(node: DaoInfo, safeAddress: Address): DaoHierarchyInfo {
-  return {
-    daoName: node.daoName,
-    safeAddress: safeAddress,
-    nodeHierarchy: {
-      parentAddress: node.nodeHierarchy.parentAddress,
-      childNodes: node.nodeHierarchy.childNodes.map(child => {
-        if (!child.safe) {
-          throw new Error('Child node does not have a safe');
-        }
-        return {
-          safeAddress: child.safe.address,
-        };
-      }),
-    },
-  };
-}
-
 /**
  * A recursive component that displays a "hierarchy" of DAOInfoCards.
  *
@@ -49,10 +39,130 @@ export function DaoHierarchyNode({
   depth: number;
 }) {
   const { safe: currentSafe } = useDaoInfoStore();
+  const { t } = useTranslation('common');
+  const safeApi = useSafeAPI();
   const [hierarchyNode, setHierarchyNode] = useState<DaoHierarchyInfo>();
-  const { addressPrefix } = useNetworkConfig();
+  const [hasErrorLoading, setErrorLoading] = useState<boolean>(false);
+  const { addressPrefix, subgraph } = useNetworkConfig();
   const chainId = useChainId();
-  const { loadDao } = useLoadDAONode();
+  const publicClient = usePublicClient();
+
+  const { getAddressContractType } = useAddressContractType();
+  const lookupModules = useDecentModules();
+
+  const [getDAOInfo] = useLazyQuery(DAOQueryDocument, {
+    context: {
+      subgraphSpace: subgraph.space,
+      subgraphSlug: subgraph.slug,
+      subgraphVersion: subgraph.version,
+    },
+  });
+
+  const getVotingStrategies = useCallback(
+    async (azoriusModule: DecentModule) => {
+      if (!publicClient) {
+        throw new Error('Public Client is not set!');
+      }
+
+      const azoriusContract = getContract({
+        abi: abis.Azorius,
+        address: azoriusModule.moduleAddress,
+        client: publicClient,
+      });
+
+      const [strategies, nextStrategy] = await azoriusContract.read.getStrategies([
+        SENTINEL_ADDRESS,
+        3n,
+      ]);
+      const result = Promise.all(
+        [...strategies, nextStrategy]
+          .filter(
+            strategyAddress =>
+              strategyAddress !== SENTINEL_ADDRESS && strategyAddress !== zeroAddress,
+          )
+          .map(async strategyAddress => ({
+            ...(await getAddressContractType(strategyAddress)),
+            strategyAddress,
+          })),
+      );
+
+      return result;
+    },
+    [getAddressContractType, publicClient],
+  );
+
+  const getGovernanceTypes = useCallback(
+    async (azoriusModule: DecentModule) => {
+      const votingStrategies = await getVotingStrategies(azoriusModule);
+
+      if (!votingStrategies) {
+        throw new Error('No voting strategies found');
+      }
+
+      if (!publicClient) {
+        throw new Error('Public Client is not set!');
+      }
+
+      let governanceTypes: DaoHierarchyStrategyType[] = [];
+
+      await Promise.all(
+        votingStrategies.map(async votingStrategy => {
+          const {
+            isLinearVotingErc20,
+            isLinearVotingErc721,
+            isLinearVotingErc20WithHatsProposalCreation,
+            isLinearVotingErc721WithHatsProposalCreation,
+          } = votingStrategy;
+          if (isLinearVotingErc20) {
+            governanceTypes.push('ERC-20');
+          } else if (isLinearVotingErc721) {
+            governanceTypes.push('ERC-721');
+          } else if (isLinearVotingErc20WithHatsProposalCreation) {
+            governanceTypes.push('ERC-20');
+          } else if (isLinearVotingErc721WithHatsProposalCreation) {
+            governanceTypes.push('ERC-721');
+          }
+        }),
+      );
+      return governanceTypes;
+    },
+    [getVotingStrategies, publicClient],
+  );
+
+  const loadDao = useCallback(
+    async (_safeAddress: Address): Promise<DaoHierarchyInfo | undefined> => {
+      if (!safeApi) {
+        throw new Error('Safe API not ready');
+      }
+      try {
+        const safe = await safeApi.getSafeInfo(_safeAddress);
+        const graphRawNodeData = await getDAOInfo({ variables: { safeAddress: _safeAddress } });
+        const modules = await lookupModules(safe.modules);
+        const graphDAOData = graphRawNodeData.data?.daos[0];
+        const azoriusModule = getAzoriusModuleFromModules(modules ?? []);
+        const votingStrategies: DaoHierarchyStrategyType[] = azoriusModule
+          ? await getGovernanceTypes(azoriusModule)
+          : ['MULTISIG'];
+        if (!graphRawNodeData || !graphDAOData) {
+          throw new Error('No data found');
+        }
+        return {
+          daoName: graphDAOData.name ?? null,
+          safeAddress: _safeAddress,
+          parentAddress: graphDAOData.parentAddress ?? null,
+          childAddresses: graphDAOData.hierarchy.map(child => child.address),
+          daoSnapshotENS: graphDAOData.snapshotENS ?? null,
+          proposalTemplatesHash: graphDAOData.proposalTemplatesHash ?? null,
+          modules,
+          votingStrategies,
+        };
+      } catch (e) {
+        setErrorLoading(true);
+        return;
+      }
+    },
+    [getDAOInfo, getGovernanceTypes, lookupModules, safeApi],
+  );
 
   useEffect(() => {
     if (safeAddress) {
@@ -66,22 +176,18 @@ export function DaoHierarchyNode({
         return;
       }
       loadDao(safeAddress).then(_node => {
-        const errorNode = _node as WithError;
-        if (!errorNode.error) {
-          const fnode = _node as DaoInfo;
-          const theNode = transformNode(fnode, safeAddress);
-          setValue(
-            {
-              cacheName: CacheKeys.HIERARCHY_DAO_INFO,
-              chainId,
-              daoAddress: safeAddress,
-            },
-            theNode,
-          );
-          setHierarchyNode(theNode);
-        } else if (errorNode.error === 'errorFailedSearch') {
-          setHierarchyNode(undefined);
+        if (!_node) {
+          setErrorLoading(true);
         }
+        setValue(
+          {
+            cacheName: CacheKeys.HIERARCHY_DAO_INFO,
+            chainId,
+            daoAddress: safeAddress,
+          },
+          _node,
+        );
+        setHierarchyNode(_node);
       });
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -100,6 +206,29 @@ export function DaoHierarchyNode({
     );
   }
 
+  if (hasErrorLoading) {
+    return (
+      <Flex
+        w="full"
+        bg="neutral-2"
+        p="1.5rem"
+        width="100%"
+        borderRadius="0.75rem"
+        border="1px"
+        borderColor="transparent"
+      >
+        <Center w="100%">
+          <Text
+            textStyle="label-base"
+            color="red-0"
+          >
+            {t('errorMySafesNotLoaded')}
+          </Text>
+        </Center>
+      </Flex>
+    );
+  }
+
   const isCurrentViewingDAO =
     currentSafe?.address.toLowerCase() === hierarchyNode.safeAddress.toLocaleLowerCase();
   return (
@@ -124,15 +253,16 @@ export function DaoHierarchyNode({
           daoName={hierarchyNode?.daoName ?? hierarchyNode.safeAddress}
           daoSnapshotENS={hierarchyNode?.daoSnapshotENS}
           isCurrentViewingDAO={isCurrentViewingDAO}
+          votingStrategies={hierarchyNode.votingStrategies}
         />
       </Link>
 
       {/* CHILD NODES */}
-      {hierarchyNode?.nodeHierarchy.childNodes.map(childNode => {
+      {hierarchyNode?.childAddresses.map(childAddress => {
         return (
           <Flex
             minH={`${NODE_HEIGHT_REM}rem`}
-            key={childNode.safeAddress}
+            key={childAddress}
             gap="1.25rem"
           >
             <Icon
@@ -140,11 +270,11 @@ export function DaoHierarchyNode({
               my={`${NODE_HEIGHT_REM / 2.5}rem`}
               ml="0.5rem"
               boxSize="32px"
-              color={currentSafe?.address === childNode.safeAddress ? 'celery-0' : 'neutral-6'}
+              color={currentSafe?.address === childAddress ? 'celery-0' : 'neutral-6'}
             />
 
             <DaoHierarchyNode
-              safeAddress={childNode.safeAddress}
+              safeAddress={childAddress}
               depth={depth + 1}
             />
           </Flex>
diff --git a/src/components/Proposals/MultisigProposalDetails/TxActions.tsx b/src/components/Proposals/MultisigProposalDetails/TxActions.tsx
index 7eef7242de..216c3146d6 100644
--- a/src/components/Proposals/MultisigProposalDetails/TxActions.tsx
+++ b/src/components/Proposals/MultisigProposalDetails/TxActions.tsx
@@ -2,7 +2,7 @@ import { Box, Button, Text, Flex } from '@chakra-ui/react';
 import { abis } from '@fractal-framework/fractal-contracts';
 import { useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { getAddress, getContract, isHex } from 'viem';
+import { getAddress, getContract, isHex, zeroAddress } from 'viem';
 import { useAccount, useWalletClient } from 'wagmi';
 import GnosisSafeL2Abi from '../../../assets/abi/GnosisSafeL2';
 import { Check } from '../../../assets/theme/custom/icons/Check';
@@ -50,7 +50,7 @@ export function TxActions({ proposal }: { proposal: MultisigProposal }) {
   const { loadSafeMultisigProposals } = useSafeMultisigProposals();
   const { data: walletClient } = useWalletClient();
 
-  const isOwner = safe?.owners?.includes(userAccount.address || '');
+  const isOwner = safe?.owners?.includes(userAccount.address ?? zeroAddress);
 
   if (!isOwner) return null;
 
diff --git a/src/components/Proposals/ProposalInfo.tsx b/src/components/Proposals/ProposalInfo.tsx
index 3abfeda4d3..dbe0237e42 100644
--- a/src/components/Proposals/ProposalInfo.tsx
+++ b/src/components/Proposals/ProposalInfo.tsx
@@ -23,7 +23,7 @@ export function ProposalInfo({
 }) {
   const metaData = useGetMetadata(proposal);
   const { t } = useTranslation('proposal');
-  const { daoSnapshotENS } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
   const { snapshotProposal } = useSnapshotProposal(proposal);
 
   const [modalType, props] = useMemo(() => {
@@ -62,10 +62,10 @@ export function ProposalInfo({
           showIcon={false}
           textColor="neutral-7"
         />
-        {snapshotProposal && (
+        {snapshotProposal && subgraphInfo && (
           <>
             <SnapshotButton
-              snapshotENS={`${daoSnapshotENS}/proposal/${snapshotProposal.proposalId}`}
+              snapshotENS={`${subgraphInfo.daoSnapshotENS}/proposal/${snapshotProposal.proposalId}`}
             />
             {(proposal as ExtendedSnapshotProposal).privacy === 'shutter' && (
               <Button
diff --git a/src/components/Proposals/index.tsx b/src/components/Proposals/index.tsx
index 86539da316..a9429205ac 100644
--- a/src/components/Proposals/index.tsx
+++ b/src/components/Proposals/index.tsx
@@ -46,7 +46,7 @@ export default function Proposals() {
     governance: { type },
     guardContracts,
   } = useFractal();
-  const { daoSnapshotENS } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
 
   const [sortBy, setSortBy] = useState<SortBy>(SortBy.Newest);
   const [filters, setFilters] = useState<FractalProposalState[]>([]);
@@ -73,12 +73,12 @@ export default function Proposals() {
         }
         break;
     }
-    if (daoSnapshotENS) {
+    if (subgraphInfo?.daoSnapshotENS) {
       options = [...options, ...FILTERS_SNAPSHOT];
     }
     setAllOptions(options);
     setFilters(options);
-  }, [daoSnapshotENS, guardContracts.freezeGuardContractAddress, type]);
+  }, [subgraphInfo?.daoSnapshotENS, guardContracts.freezeGuardContractAddress, type]);
 
   const toggleFilter = (filter: FractalProposalState) => {
     setFilters(prevState => {
diff --git a/src/components/SafeSettings/SettingsNavigation.tsx b/src/components/SafeSettings/SettingsNavigation.tsx
index 5c942b14a8..224ce24011 100644
--- a/src/components/SafeSettings/SettingsNavigation.tsx
+++ b/src/components/SafeSettings/SettingsNavigation.tsx
@@ -88,7 +88,7 @@ export default function SettingsNavigation() {
   const { t } = useTranslation('settings');
   const { addressPrefix } = useNetworkConfig();
   const { governance } = useFractal();
-  const { safe, fractalModules } = useDaoInfoStore();
+  const { safe, modules } = useDaoInfoStore();
   const azoriusGovernance = governance as AzoriusGovernance;
 
   return (
@@ -143,7 +143,7 @@ export default function SettingsNavigation() {
               textStyle="body-base"
               color="neutral-7"
             >
-              {fractalModules.length + safe.guard ? 1 : 0}
+              {(modules ?? []).length + (safe?.guard ? 1 : 0)}
             </Text>
           </SettingsLink>
           <SettingsLink
diff --git a/src/components/ui/cards/DAOInfoCard.tsx b/src/components/ui/cards/DAOInfoCard.tsx
index ce1bf66e96..1f76313b9e 100644
--- a/src/components/ui/cards/DAOInfoCard.tsx
+++ b/src/components/ui/cards/DAOInfoCard.tsx
@@ -36,7 +36,7 @@ export function DAOInfoCard() {
     );
   }
 
-  const daoName = node.daoName || displayName;
+  const daoName = node.subgraphInfo?.daoName || displayName;
 
   return (
     <Box>
@@ -62,7 +62,7 @@ export function DAOInfoCard() {
             />
 
             {/* PARENT TAG */}
-            {node.nodeHierarchy.childNodes.length > 0 && (
+            {!!node.subgraphInfo && node.subgraphInfo.childAddresses.length > 0 && (
               <Link
                 to={DAO_ROUTES.hierarchy.relative(addressPrefix, displayedAddress)}
                 as={RouterLink}
@@ -100,7 +100,9 @@ export function DAOInfoCard() {
         <AddressCopier address={displayedAddress} />
 
         {/* SNAPSHOT ICON LINK */}
-        {node.daoSnapshotENS && <SnapshotButton snapshotENS={node.daoSnapshotENS} />}
+        {node.subgraphInfo?.daoSnapshotENS && (
+          <SnapshotButton snapshotENS={node.subgraphInfo.daoSnapshotENS} />
+        )}
       </Flex>
     </Box>
   );
diff --git a/src/components/ui/cards/DAONodeInfoCard.tsx b/src/components/ui/cards/DAONodeInfoCard.tsx
index bd530e700a..f8fe0a49e2 100644
--- a/src/components/ui/cards/DAONodeInfoCard.tsx
+++ b/src/components/ui/cards/DAONodeInfoCard.tsx
@@ -1,6 +1,7 @@
-import { Flex, Text, VStack } from '@chakra-ui/react';
+import { Flex, Box, Text, VStack } from '@chakra-ui/react';
 import { Address } from 'viem';
 import { useAccountFavorites } from '../../../hooks/DAO/loaders/useFavorites';
+import { DaoHierarchyStrategyType } from '../../../types';
 import { SnapshotButton } from '../badges/Snapshot';
 import { FavoriteIcon } from '../icons/FavoriteIcon';
 import AddressCopier from '../links/AddressCopier';
@@ -8,13 +9,6 @@ import AddressCopier from '../links/AddressCopier';
 export const NODE_HEIGHT_REM = 6.75;
 export const NODE_MARGIN_TOP_REM = 1.25;
 
-interface DAONodeInfoCardProps {
-  daoAddress: Address;
-  daoName: string;
-  daoSnapshotENS?: string;
-  isCurrentViewingDAO: boolean;
-}
-
 /**
  * Info card used on each DAO in the hierarchy page.
  *
@@ -25,13 +19,19 @@ interface DAONodeInfoCardProps {
  * Simply using the useFractal() hook to get info will end up with the current DAO's
  * context being displayed in ALL the node cards in a hierarchy, which is incorrect.
  */
-export function DAONodeInfoCard(props: DAONodeInfoCardProps) {
-  const { daoAddress, daoName, daoSnapshotENS, isCurrentViewingDAO } = props;
+export function DAONodeInfoCard(props: {
+  daoAddress: Address;
+  daoName: string;
+  daoSnapshotENS: string | null;
+  isCurrentViewingDAO: boolean;
+  votingStrategies: DaoHierarchyStrategyType[];
+}) {
+  const { daoAddress, daoName, daoSnapshotENS, isCurrentViewingDAO, votingStrategies } = props;
 
   const { toggleFavorite, isFavorite } = useAccountFavorites();
 
   return (
-    <Flex
+    <Box
       minH={`${NODE_HEIGHT_REM}rem`}
       bg="neutral-2"
       _hover={
@@ -49,33 +49,57 @@ export function DAONodeInfoCard(props: DAONodeInfoCardProps) {
       border={isCurrentViewingDAO ? '4px solid' : '1px'}
       borderColor={isCurrentViewingDAO ? 'neutral-4' : 'transparent'}
     >
-      <VStack
-        gap="0.5rem"
-        alignItems="left"
-      >
-        {/* DAO NAME */}
-        <Flex
-          gap="0.5rem"
-          alignItems="center"
-        >
-          {/* DAO NAME */}
+      <Flex justifyItems="space-between">
+        <Flex w="full">
+          <VStack
+            gap="0.5rem"
+            alignItems="left"
+          >
+            {/* DAO NAME */}
+            <Flex
+              gap="0.5rem"
+              alignItems="center"
+            >
+              {/* DAO NAME */}
 
-          <Text textStyle="display-xl">{daoName}</Text>
+              <Text textStyle="display-xl">{daoName}</Text>
 
-          {/* FAVORITE ICON */}
-          <FavoriteIcon
-            isFavorite={isFavorite(daoAddress)}
-            toggleFavoriteCallback={() => toggleFavorite(daoAddress, daoName)}
-            data-testid="DAOInfo-favorite"
-          />
+              {/* FAVORITE ICON */}
+              <FavoriteIcon
+                isFavorite={isFavorite(daoAddress)}
+                toggleFavoriteCallback={() => toggleFavorite(daoAddress, daoName)}
+                data-testid="DAOInfo-favorite"
+              />
 
-          {/* SNAPSHOT ICON LINK */}
-          {daoSnapshotENS && <SnapshotButton snapshotENS={daoSnapshotENS} />}
-        </Flex>
+              {/* SNAPSHOT ICON LINK */}
+              {daoSnapshotENS && <SnapshotButton snapshotENS={daoSnapshotENS} />}
+            </Flex>
 
-        {/* DAO ADDRESS */}
-        <AddressCopier address={daoAddress} />
-      </VStack>
-    </Flex>
+            {/* DAO ADDRESS */}
+            <AddressCopier address={daoAddress} />
+          </VStack>
+        </Flex>
+        <Flex gap="0.5rem">
+          {votingStrategies.map((type, index) => (
+            <Box
+              key={index}
+              borderRadius="9999px"
+              bg="neutral-3"
+              px="0.75rem"
+              py="0.25rem"
+              h="fit-content"
+            >
+              <Text
+                textStyle="label-large"
+                color="lilac-0"
+                whiteSpace="nowrap"
+              >
+                {type}
+              </Text>
+            </Box>
+          ))}
+        </Flex>
+      </Flex>
+    </Box>
   );
 }
diff --git a/src/components/ui/menus/ManageDAO/ManageDAOMenu.tsx b/src/components/ui/menus/ManageDAO/ManageDAOMenu.tsx
index 415719a575..8f1f1b8d88 100644
--- a/src/components/ui/menus/ManageDAO/ManageDAOMenu.tsx
+++ b/src/components/ui/menus/ManageDAO/ManageDAOMenu.tsx
@@ -28,15 +28,18 @@ export function ManageDAOMenu() {
     guard,
     guardContracts,
   } = useFractal();
-  const node = useDaoInfoStore();
+  const dao = useDaoInfoStore();
   const currentTime = BigInt(useBlockTimestamp());
   const navigate = useNavigate();
-  const safeAddress = node.safe?.address;
+  const safeAddress = dao.safe?.address;
   const { canUserCreateProposal } = useCanUserCreateProposal();
   const { getUserERC721VotingTokens } = useUserERC721VotingTokens(safeAddress ?? null, null, false);
   const { handleClawBack } = useClawBack({
-    parentAddress: node.nodeHierarchy.parentAddress,
-    childSafeInfo: node,
+    parentAddress: dao.subgraphInfo?.parentAddress ?? null,
+    childSafeInfo: {
+      daoAddress: dao.safe?.address,
+      modules: dao.modules,
+    },
   });
 
   const { addressPrefix } = useNetworkConfig();
@@ -85,27 +88,35 @@ export function ManageDAOMenu() {
           });
           return contract.write.castFreezeVote();
         } else if (freezeVotingType === FreezeVotingType.ERC721) {
-          getUserERC721VotingTokens(node.nodeHierarchy.parentAddress, null).then(tokensInfo => {
-            if (!guardContracts.freezeVotingContractAddress) {
-              throw new Error('freeze voting contract address not set');
-            }
-            if (!walletClient) {
-              throw new Error('wallet client not set');
-            }
-            const freezeERC721VotingContract = getContract({
-              abi: abis.ERC721FreezeVoting,
-              address: guardContracts.freezeVotingContractAddress,
-              client: walletClient,
-            });
-            return freezeERC721VotingContract.write.castFreezeVote([
-              tokensInfo.totalVotingTokenAddresses,
-              tokensInfo.totalVotingTokenIds.map(i => BigInt(i)),
-            ]);
-          });
+          getUserERC721VotingTokens(dao.subgraphInfo?.parentAddress ?? null, null).then(
+            tokensInfo => {
+              if (!guardContracts.freezeVotingContractAddress) {
+                throw new Error('freeze voting contract address not set');
+              }
+              if (!walletClient) {
+                throw new Error('wallet client not set');
+              }
+              const freezeERC721VotingContract = getContract({
+                abi: abis.ERC721FreezeVoting,
+                address: guardContracts.freezeVotingContractAddress,
+                client: walletClient,
+              });
+              return freezeERC721VotingContract.write.castFreezeVote([
+                tokensInfo.totalVotingTokenAddresses,
+                tokensInfo.totalVotingTokenIds.map(i => BigInt(i)),
+              ]);
+            },
+          );
         }
       },
     }),
-    [getUserERC721VotingTokens, guardContracts, node.nodeHierarchy.parentAddress, walletClient],
+    [
+      dao.subgraphInfo?.parentAddress,
+      getUserERC721VotingTokens,
+      guardContracts.freezeVotingContractAddress,
+      guardContracts.freezeVotingType,
+      walletClient,
+    ],
   );
 
   const options = useMemo(() => {
@@ -157,7 +168,7 @@ export function ManageDAOMenu() {
       guard.isFrozen &&
       guard.userHasVotes
     ) {
-      const fractalModule = node.fractalModules.find(
+      const fractalModule = (dao.modules ?? []).find(
         module => module.moduleType === FractalModuleType.FRACTAL,
       );
       if (fractalModule) {
@@ -177,18 +188,22 @@ export function ManageDAOMenu() {
       return optionsArr;
     }
   }, [
-    guard,
-    currentTime,
-    navigate,
-    safeAddress,
-    type,
     handleClawBack,
-    canUserCreateProposal,
     handleModifyGovernance,
     handleNavigateToSettings,
+    guard.freezeProposalCreatedTime,
+    guard.freezeProposalPeriod,
+    guard.freezePeriod,
+    guard.userHasVotes,
+    guard.isFrozen,
+    currentTime,
+    safeAddress,
+    navigate,
     addressPrefix,
+    type,
     freezeOption,
-    node.fractalModules,
+    dao.modules,
+    canUserCreateProposal,
   ]);
 
   return (
diff --git a/src/components/ui/modals/ForkProposalTemplateModal.tsx b/src/components/ui/modals/ForkProposalTemplateModal.tsx
index 3d3aaeadf0..2c6d07c8ff 100644
--- a/src/components/ui/modals/ForkProposalTemplateModal.tsx
+++ b/src/components/ui/modals/ForkProposalTemplateModal.tsx
@@ -33,7 +33,7 @@ export default function ForkProposalTemplateModal({
   const navigate = useNavigate();
   const publicClient = usePublicClient();
   const { chain, addressPrefix } = useNetworkConfig();
-  const { proposalTemplatesHash } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
 
   const { isSafe, isSafeLoading } = useIsSafe(targetDAOAddress);
   const { getCanUserCreateProposal } = useCanUserCreateProposal();
@@ -74,11 +74,14 @@ export default function ForkProposalTemplateModal({
   }, [getCanUserCreateProposal, inputValue, isSafe, isSafeLoading, chain, publicClient, t]);
 
   const handleSubmit = () => {
+    if (!subgraphInfo?.proposalTemplatesHash) {
+      throw new Error('No proposal templates hash found');
+    }
     navigate(
       `${DAO_ROUTES.proposalTemplateNew.relative(
         addressPrefix,
         targetDAOAddress,
-      )}&templatesHash=${proposalTemplatesHash}&templateIndex=${templateIndex}`,
+      )}&templatesHash=${subgraphInfo?.proposalTemplatesHash}&templateIndex=${templateIndex}`,
     );
     onClose();
   };
diff --git a/src/components/ui/page/Header/PageHeader.tsx b/src/components/ui/page/Header/PageHeader.tsx
index 405def112c..3cff4aca89 100644
--- a/src/components/ui/page/Header/PageHeader.tsx
+++ b/src/components/ui/page/Header/PageHeader.tsx
@@ -32,7 +32,7 @@ function PageHeader({
   children,
   showSafeAddress,
 }: PageHeaderProps) {
-  const { safe, daoName } = useDaoInfoStore();
+  const { safe, subgraphInfo } = useDaoInfoStore();
 
   const { addressPrefix } = useNetworkConfig();
   const safeAddress = safe?.address;
@@ -41,15 +41,17 @@ function PageHeader({
 
   useEffect(() => {
     if (hasDAOLink && safeAddress) {
+      const safeAddressSubstring = subgraphInfo?.daoName ?? createAccountSubstring(safeAddress);
+      if (!safeAddressSubstring) return;
       setLinks([
         {
-          terminus: daoName || (safeAddress && createAccountSubstring(safeAddress)) || '',
+          terminus: safeAddressSubstring,
           path: DAO_ROUTES.dao.relative(addressPrefix, safeAddress),
         },
         ...breadcrumbs,
       ]);
     }
-  }, [hasDAOLink, daoName, safeAddress, breadcrumbs, addressPrefix]);
+  }, [hasDAOLink, subgraphInfo?.daoName, safeAddress, breadcrumbs, addressPrefix]);
 
   const showAction = !!buttonProps || !!ButtonIcon || !!children;
 
diff --git a/src/hooks/DAO/loaders/snapshot/useSnapshotProposal.ts b/src/hooks/DAO/loaders/snapshot/useSnapshotProposal.ts
index 23e8fe7bd9..a99da407ef 100644
--- a/src/hooks/DAO/loaders/snapshot/useSnapshotProposal.ts
+++ b/src/hooks/DAO/loaders/snapshot/useSnapshotProposal.ts
@@ -18,7 +18,7 @@ export default function useSnapshotProposal(proposal: FractalProposal | null | u
     useState<ExtendedSnapshotProposal | null>(null);
   const { address } = useAccount();
 
-  const { daoSnapshotENS } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
   const snaphshotGraphQlClient = useMemo(() => createSnapshotGraphQlClient(), []);
 
   const snapshotProposal = useMemo(() => {
@@ -211,7 +211,7 @@ export default function useSnapshotProposal(proposal: FractalProposal | null | u
       query UserVotingWeight {
           vp(
               voter: "${address}"
-              space: "${daoSnapshotENS}"
+              space: "${subgraphInfo?.daoSnapshotENS}"
               proposal: "${snapshotProposal.snapshotProposalId}"
           ) {
               vp
@@ -236,7 +236,12 @@ export default function useSnapshotProposal(proposal: FractalProposal | null | u
     }
 
     return emptyVotingWeight;
-  }, [address, snapshotProposal?.snapshotProposalId, snaphshotGraphQlClient, daoSnapshotENS]);
+  }, [
+    address,
+    snapshotProposal?.snapshotProposalId,
+    snaphshotGraphQlClient,
+    subgraphInfo?.daoSnapshotENS,
+  ]);
 
   return {
     loadVotingWeight,
diff --git a/src/hooks/DAO/loaders/snapshot/useSnapshotProposals.ts b/src/hooks/DAO/loaders/snapshot/useSnapshotProposals.ts
index 61338ded59..7c1c2580f5 100644
--- a/src/hooks/DAO/loaders/snapshot/useSnapshotProposals.ts
+++ b/src/hooks/DAO/loaders/snapshot/useSnapshotProposals.ts
@@ -8,12 +8,12 @@ import { createSnapshotGraphQlClient } from './';
 
 export const useSnapshotProposals = () => {
   const { action } = useFractal();
-  const { daoSnapshotENS } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
   const currentSnapshotENS = useRef<string | undefined>();
   const snaphshotGraphQlClient = useMemo(() => createSnapshotGraphQlClient(), []);
 
   const loadSnapshotProposals = useCallback(async () => {
-    if (snaphshotGraphQlClient) {
+    if (snaphshotGraphQlClient && !!subgraphInfo) {
       snaphshotGraphQlClient
         .query({
           query: gql`
@@ -21,7 +21,7 @@ export const useSnapshotProposals = () => {
         proposals(
           first: 50,
           where: {
-            space_in: ["${daoSnapshotENS}"]
+            space_in: ["${subgraphInfo.daoSnapshotENS}"]
           },
           orderBy: "created",
           orderDirection: desc
@@ -71,11 +71,15 @@ export const useSnapshotProposals = () => {
           });
         });
     }
-  }, [action, daoSnapshotENS, snaphshotGraphQlClient]);
+  }, [snaphshotGraphQlClient, subgraphInfo, action]);
 
   useEffect(() => {
-    if (!daoSnapshotENS || daoSnapshotENS === currentSnapshotENS.current) return;
-    currentSnapshotENS.current = daoSnapshotENS;
+    if (
+      !subgraphInfo?.daoSnapshotENS ||
+      subgraphInfo?.daoSnapshotENS === currentSnapshotENS.current
+    )
+      return;
+    currentSnapshotENS.current = subgraphInfo.daoSnapshotENS;
     loadSnapshotProposals();
-  }, [daoSnapshotENS, loadSnapshotProposals]);
+  }, [subgraphInfo?.daoSnapshotENS, loadSnapshotProposals]);
 };
diff --git a/src/hooks/DAO/loaders/useFractalModules.ts b/src/hooks/DAO/loaders/useDecentModules.ts
similarity index 89%
rename from src/hooks/DAO/loaders/useFractalModules.ts
rename to src/hooks/DAO/loaders/useDecentModules.ts
index 8d6185b561..da13118917 100644
--- a/src/hooks/DAO/loaders/useFractalModules.ts
+++ b/src/hooks/DAO/loaders/useDecentModules.ts
@@ -1,10 +1,10 @@
 import { useCallback } from 'react';
 import { getAddress } from 'viem';
 import { usePublicClient } from 'wagmi';
-import { FractalModuleData, FractalModuleType } from '../../../types';
+import { DecentModule, FractalModuleType } from '../../../types';
 import { useAddressContractType } from '../../utils/useAddressContractType';
 
-export const useFractalModules = () => {
+export const useDecentModules = () => {
   const { getAddressContractType } = useAddressContractType();
   const publicClient = usePublicClient();
   const lookupModules = useCallback(
@@ -15,7 +15,7 @@ export const useFractalModules = () => {
 
           const masterCopyData = await getAddressContractType(moduleAddress);
 
-          let safeModule: FractalModuleData;
+          let safeModule: DecentModule;
 
           if (masterCopyData.isModuleAzorius && publicClient) {
             safeModule = {
diff --git a/src/hooks/DAO/loaders/useFractalGuardContracts.ts b/src/hooks/DAO/loaders/useFractalGuardContracts.ts
index 1b7637131d..9600a335ac 100644
--- a/src/hooks/DAO/loaders/useFractalGuardContracts.ts
+++ b/src/hooks/DAO/loaders/useFractalGuardContracts.ts
@@ -6,16 +6,16 @@ import { useFractal } from '../../../providers/App/AppProvider';
 import { GuardContractAction } from '../../../providers/App/guardContracts/action';
 import { useNetworkConfig } from '../../../providers/NetworkConfig/NetworkConfigProvider';
 import { useDaoInfoStore } from '../../../store/daoInfo/useDaoInfoStore';
-import { FreezeGuardType, FreezeVotingType, SafeInfoResponseWithGuard } from '../../../types';
+import { FreezeGuardType, FreezeVotingType } from '../../../types';
 import { useAddressContractType } from '../../utils/useAddressContractType';
-import { FractalModuleData, FractalModuleType } from './../../../types/fractal';
+import { DecentModule, FractalModuleType, GnosisSafe } from './../../../types/fractal';
 
 export const useFractalGuardContracts = ({ loadOnMount = true }: { loadOnMount?: boolean }) => {
   // load key for component; helps prevent unnecessary calls
   const loadKey = useRef<string>();
   const { action } = useFractal();
 
-  const { fractalModules, safe, isHierarchyLoaded } = useDaoInfoStore();
+  const { modules, safe, subgraphInfo } = useDaoInfoStore();
 
   const safeAddress = safe?.address;
 
@@ -26,7 +26,7 @@ export const useFractalGuardContracts = ({ loadOnMount = true }: { loadOnMount?:
   const publicClient = usePublicClient();
 
   const loadFractalGuardContracts = useCallback(
-    async (_safe: SafeInfoResponseWithGuard, _fractalModules: FractalModuleData[]) => {
+    async (_safe: GnosisSafe, _fractalModules: DecentModule[]) => {
       if (!publicClient) {
         return;
       }
@@ -124,19 +124,19 @@ export const useFractalGuardContracts = ({ loadOnMount = true }: { loadOnMount?:
   );
 
   const setGuardContracts = useCallback(async () => {
-    if (!safe) return;
-    const contracts = await loadFractalGuardContracts(safe, fractalModules);
+    if (!safe || modules === null) return;
+    const contracts = await loadFractalGuardContracts(safe, modules);
     if (!contracts) return;
     action.dispatch({ type: GuardContractAction.SET_GUARD_CONTRACT, payload: contracts });
-  }, [action, safe, fractalModules, loadFractalGuardContracts]);
+  }, [action, safe, modules, loadFractalGuardContracts]);
 
   useEffect(() => {
     if (
       loadOnMount &&
       safeAddress &&
       safeAddress + chain.id !== loadKey.current &&
-      isHierarchyLoaded &&
-      safe
+      subgraphInfo !== null &&
+      safe !== null
     ) {
       loadKey.current = safeAddress + chain.id;
       setGuardContracts();
@@ -145,6 +145,6 @@ export const useFractalGuardContracts = ({ loadOnMount = true }: { loadOnMount?:
     if (!safeAddress) {
       loadKey.current = undefined;
     }
-  }, [setGuardContracts, isHierarchyLoaded, loadOnMount, chain, safeAddress, safe]);
+  }, [setGuardContracts, subgraphInfo, loadOnMount, chain, safeAddress, safe]);
   return loadFractalGuardContracts;
 };
diff --git a/src/hooks/DAO/loaders/useFractalNode.ts b/src/hooks/DAO/loaders/useFractalNode.ts
index 160faa1bdf..007db1291e 100644
--- a/src/hooks/DAO/loaders/useFractalNode.ts
+++ b/src/hooks/DAO/loaders/useFractalNode.ts
@@ -1,8 +1,12 @@
+import { useLazyQuery } from '@apollo/client';
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { Address } from 'viem';
+import { Address, getAddress, isAddress } from 'viem';
+import { DAOQueryDocument } from '../../../../.graphclient';
 import { useFractal } from '../../../providers/App/AppProvider';
+import { useSafeAPI } from '../../../providers/App/hooks/useSafeAPI';
+import { useNetworkConfig } from '../../../providers/NetworkConfig/NetworkConfigProvider';
 import { useDaoInfoStore } from '../../../store/daoInfo/useDaoInfoStore';
-import { useLoadDAONode } from './useLoadDAONode';
+import { useDecentModules } from './useDecentModules';
 
 export const useFractalNode = ({
   addressPrefix,
@@ -11,14 +15,23 @@ export const useFractalNode = ({
   addressPrefix?: string;
   safeAddress?: Address;
 }) => {
+  const safeApi = useSafeAPI();
+  const lookupModules = useDecentModules();
   // tracks the current valid Safe address and chain id; helps prevent unnecessary calls
   const currentValidSafe = useRef<string>();
   const [errorLoading, setErrorLoading] = useState<boolean>(false);
+  const { subgraph } = useNetworkConfig();
+  const [getDAOInfo] = useLazyQuery(DAOQueryDocument, {
+    context: {
+      subgraphSpace: subgraph.space,
+      subgraphSlug: subgraph.slug,
+      subgraphVersion: subgraph.version,
+    },
+  });
 
   const { action } = useFractal();
 
-  const { setDaoInfo } = useDaoInfoStore();
-  const { loadDao } = useLoadDAONode();
+  const { setDaoInfo, setSafeInfo, setDecentModules } = useDaoInfoStore();
 
   const reset = useCallback(
     ({ error }: { error: boolean }) => {
@@ -35,19 +48,41 @@ export const useFractalNode = ({
       setErrorLoading(false);
 
       try {
-        const daoInfo = await loadDao(safeAddress);
-        if (!daoInfo.safe) {
-          throw new Error('Invalid Safe');
+        const safeInfo = await safeApi.getSafeData(safeAddress);
+        setSafeInfo(safeInfo);
+        const modules = await lookupModules(safeInfo.modules);
+        const graphRawNodeData = await getDAOInfo({ variables: { safeAddress } });
+        const graphDAOData = graphRawNodeData.data?.daos[0];
+        if (!graphRawNodeData || !graphDAOData) {
+          throw new Error('No data found');
         }
-        setDaoInfo(daoInfo);
+        setDecentModules(modules);
+
+        setDaoInfo({
+          parentAddress: isAddress(graphDAOData.parentAddress)
+            ? getAddress(graphDAOData.parentAddress)
+            : null,
+          childAddresses: graphDAOData.hierarchy.map(child => getAddress(child.address)),
+          daoName: graphDAOData.name ?? null,
+          daoSnapshotENS: graphDAOData.snapshotENS ?? null,
+          proposalTemplatesHash: graphDAOData.proposalTemplatesHash ?? null,
+        });
       } catch (e) {
-        // TODO: this is the thing causing an error when
-        // trying to load a DAO with a valid address which is not a Safe
         reset({ error: true });
         return;
       }
     }
-  }, [addressPrefix, safeAddress, loadDao, setDaoInfo, reset]);
+  }, [
+    addressPrefix,
+    safeAddress,
+    safeApi,
+    setSafeInfo,
+    lookupModules,
+    getDAOInfo,
+    setDecentModules,
+    setDaoInfo,
+    reset,
+  ]);
 
   useEffect(() => {
     if (`${addressPrefix}${safeAddress}` !== currentValidSafe.current) {
diff --git a/src/hooks/DAO/loaders/useGovernanceContracts.ts b/src/hooks/DAO/loaders/useGovernanceContracts.ts
index bec6c28496..02ebfd6baf 100644
--- a/src/hooks/DAO/loaders/useGovernanceContracts.ts
+++ b/src/hooks/DAO/loaders/useGovernanceContracts.ts
@@ -19,12 +19,12 @@ export const useGovernanceContracts = () => {
   const { getAddressContractType } = useAddressContractType();
 
   const { getVotingStrategies } = useVotingStrategyAddress();
-  const { fractalModules, isModulesLoaded, safe } = node;
+  const { modules, safe } = node;
 
   const safeAddress = safe?.address;
 
   const loadGovernanceContracts = useCallback(async () => {
-    const azoriusModule = getAzoriusModuleFromModules(fractalModules);
+    const azoriusModule = getAzoriusModuleFromModules(modules ?? []);
 
     const votingStrategies = await getVotingStrategies();
 
@@ -137,15 +137,15 @@ export const useGovernanceContracts = () => {
         },
       });
     }
-  }, [action, fractalModules, getVotingStrategies, publicClient, getAddressContractType]);
+  }, [action, modules, getVotingStrategies, publicClient, getAddressContractType]);
 
   useEffect(() => {
-    if (currentValidAddress.current !== safeAddress && isModulesLoaded) {
+    if (currentValidAddress.current !== safeAddress && modules !== null) {
       loadGovernanceContracts();
       currentValidAddress.current = safeAddress;
     }
     if (!safeAddress) {
       currentValidAddress.current = null;
     }
-  }, [isModulesLoaded, loadGovernanceContracts, safeAddress]);
+  }, [modules, loadGovernanceContracts, safeAddress]);
 };
diff --git a/src/hooks/DAO/loaders/useLoadDAONode.ts b/src/hooks/DAO/loaders/useLoadDAONode.ts
deleted file mode 100644
index 4d18dc9612..0000000000
--- a/src/hooks/DAO/loaders/useLoadDAONode.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import { useLazyQuery } from '@apollo/client';
-import { useCallback } from 'react';
-import { Address, getAddress, isAddress } from 'viem';
-import { DAO, DAOQueryDocument } from '../../../../.graphclient';
-import { useSafeAPI } from '../../../providers/App/hooks/useSafeAPI';
-import { useNetworkConfig } from '../../../providers/NetworkConfig/NetworkConfigProvider';
-import { DaoInfo } from '../../../types';
-import { useGetSafeName } from '../../utils/useGetSafeName';
-import { useFractalModules } from './useFractalModules';
-
-type DAOInfoWithoutLoaders = Omit<DaoInfo, 'isModulesLoaded' | 'isHierarchyLoaded'>;
-
-export const useLoadDAONode = () => {
-  const safeAPI = useSafeAPI();
-  const { getSafeName } = useGetSafeName();
-  const lookupModules = useFractalModules();
-  const { subgraph } = useNetworkConfig();
-  const [getDAOInfo] = useLazyQuery(DAOQueryDocument, {
-    context: {
-      subgraphSpace: subgraph.space,
-      subgraphSlug: subgraph.slug,
-      subgraphVersion: subgraph.version,
-    },
-  });
-
-  const getDAOWithHierarchyData = useCallback(
-    async (dao: DAO) => {
-      const childData: DAOInfoWithoutLoaders[] = [];
-      for await (const child of dao.hierarchy) {
-        const safe = await safeAPI.getSafeData(getAddress(child.address));
-        childData.push({
-          fractalModules: [],
-          safe: safe,
-          nodeHierarchy: {
-            parentAddress: isAddress(child.parentAddress) ? getAddress(child.parentAddress) : null,
-            childNodes: await getDAOWithHierarchyData(child),
-          },
-          daoName: child.name ?? null,
-          daoSnapshotENS: child.snapshotENS ?? undefined,
-        });
-      }
-      return childData;
-    },
-    [safeAPI],
-  );
-
-  const loadDao = useCallback(
-    async (safeAddress: Address): Promise<DaoInfo> => {
-      if (safeAPI) {
-        try {
-          const graphRawNodeData = await getDAOInfo({ variables: { safeAddress } });
-          const graphDAOData = graphRawNodeData.data?.daos[0];
-          if (!graphRawNodeData || !graphDAOData) {
-            throw new Error('No data found');
-          }
-          const currentSafe = await safeAPI.getSafeData(safeAddress);
-          const daoWithHierarchyData: DAOInfoWithoutLoaders = {
-            fractalModules: await lookupModules(currentSafe.modules),
-            safe: currentSafe,
-            nodeHierarchy: {
-              parentAddress: isAddress(graphDAOData.parentAddress)
-                ? getAddress(graphDAOData.parentAddress)
-                : null,
-              childNodes: await getDAOWithHierarchyData(graphDAOData),
-            },
-            daoName: graphDAOData.name ?? (await getSafeName(currentSafe.address)),
-            daoSnapshotENS:
-              graphDAOData.snapshotENS === null || graphDAOData.snapshotENS === undefined
-                ? undefined
-                : graphDAOData.snapshotENS,
-          };
-          return daoWithHierarchyData;
-        } catch (e) {
-          // @note There is a recurring error (AbortError: signal is aborted without reason)
-          // related to the getDAOInfo query. This error does not seem to affect the app's functionality.
-          throw new Error('Error loading DAO');
-        }
-      } else {
-        throw new Error('SafeAPI not set');
-      }
-    },
-    [getDAOInfo, getDAOWithHierarchyData, getSafeName, lookupModules, safeAPI],
-  );
-
-  return { loadDao };
-};
diff --git a/src/hooks/DAO/proposal/useCastSnapshotVote.ts b/src/hooks/DAO/proposal/useCastSnapshotVote.ts
index 26a69b2949..d7a26b1c18 100644
--- a/src/hooks/DAO/proposal/useCastSnapshotVote.ts
+++ b/src/hooks/DAO/proposal/useCastSnapshotVote.ts
@@ -12,7 +12,7 @@ const useCastSnapshotVote = (extendedSnapshotProposal: ExtendedSnapshotProposal
   const [selectedChoice, setSelectedChoice] = useState<number>();
   const [snapshotWeightedChoice, setSnapshotWeightedChoice] = useState<number[]>([]);
 
-  const { daoSnapshotENS } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
 
   const { data: walletClient } = useWalletClient();
 
@@ -36,7 +36,7 @@ const useCastSnapshotVote = (extendedSnapshotProposal: ExtendedSnapshotProposal
 
   const castSnapshotVote = useCallback(
     async (onSuccess?: () => Promise<void>) => {
-      if (daoSnapshotENS && extendedSnapshotProposal && walletClient) {
+      if (subgraphInfo?.daoSnapshotENS && extendedSnapshotProposal && walletClient) {
         let toastId;
         const mappedSnapshotWeightedChoice: { [choiceKey: number]: number } = {};
         if (extendedSnapshotProposal.type === 'weighted') {
@@ -60,7 +60,7 @@ const useCastSnapshotVote = (extendedSnapshotProposal: ExtendedSnapshotProposal
               extendedSnapshotProposal.proposalId,
             );
             await submitSnapshotVote(walletClient, {
-              space: daoSnapshotENS,
+              space: subgraphInfo.daoSnapshotENS,
               proposal: extendedSnapshotProposal.proposalId,
               type: extendedSnapshotProposal.type,
               privacy: extendedSnapshotProposal.privacy,
@@ -69,7 +69,7 @@ const useCastSnapshotVote = (extendedSnapshotProposal: ExtendedSnapshotProposal
             });
           } else {
             await submitSnapshotVote(walletClient, {
-              space: daoSnapshotENS,
+              space: subgraphInfo.daoSnapshotENS,
               proposal: extendedSnapshotProposal.proposalId,
               type: extendedSnapshotProposal.type,
               choice,
@@ -92,7 +92,7 @@ const useCastSnapshotVote = (extendedSnapshotProposal: ExtendedSnapshotProposal
     },
     [
       walletClient,
-      daoSnapshotENS,
+      subgraphInfo?.daoSnapshotENS,
       extendedSnapshotProposal,
       selectedChoice,
       snapshotWeightedChoice,
diff --git a/src/hooks/DAO/proposal/useSubmitProposal.ts b/src/hooks/DAO/proposal/useSubmitProposal.ts
index a274265de2..05efdc6f7e 100644
--- a/src/hooks/DAO/proposal/useSubmitProposal.ts
+++ b/src/hooks/DAO/proposal/useSubmitProposal.ts
@@ -26,7 +26,7 @@ import { useDaoInfoStore } from '../../../store/daoInfo/useDaoInfoStore';
 import { CreateProposalMetadata, MetaTransaction, ProposalExecuteData } from '../../../types';
 import { buildSafeApiUrl, getAzoriusModuleFromModules } from '../../../utils';
 import useVotingStrategiesAddresses from '../../utils/useVotingStrategiesAddresses';
-import { useFractalModules } from '../loaders/useFractalModules';
+import { useDecentModules } from '../loaders/useDecentModules';
 import { useLoadDAOProposals } from '../loaders/useLoadDAOProposals';
 
 export type SubmitProposalFunction = ({
@@ -77,12 +77,15 @@ export default function useSubmitProposal() {
     },
     action,
   } = useFractal();
-  const { safe, fractalModules } = useDaoInfoStore();
+  const { safe, modules } = useDaoInfoStore();
   const safeAPI = useSafeAPI();
 
   const globalAzoriusContract = useMemo(() => {
-    const azoriusModule = getAzoriusModuleFromModules(fractalModules);
-    if (!azoriusModule || !walletClient) {
+    if (!modules || !walletClient) {
+      return;
+    }
+    const azoriusModule = getAzoriusModuleFromModules(modules);
+    if (!azoriusModule) {
       return;
     }
 
@@ -91,9 +94,9 @@ export default function useSubmitProposal() {
       address: azoriusModule.moduleAddress,
       client: walletClient,
     });
-  }, [fractalModules, walletClient]);
+  }, [modules, walletClient]);
 
-  const lookupModules = useFractalModules();
+  const lookupModules = useDecentModules();
   const {
     chain,
     safeBaseURL,
@@ -313,8 +316,8 @@ export default function useSubmitProposal() {
         // Submitting proposal to any DAO out of global context
         const votingStrategies = await getVotingStrategies(safeAddress);
         const safeInfo = await safeAPI.getSafeInfo(safeAddress);
-        const modules = await lookupModules(safeInfo.modules);
-        const azoriusModule = getAzoriusModuleFromModules(modules);
+        const decentModules = await lookupModules(safeInfo.modules);
+        const azoriusModule = getAzoriusModuleFromModules(decentModules);
         if (!azoriusModule || !votingStrategies) {
           await submitMultisigProposal({
             proposalData,
@@ -371,7 +374,6 @@ export default function useSubmitProposal() {
             failedToastMessage,
             nonce,
             successCallback,
-            safeAddress: safe?.address,
           });
         } else {
           const userProposerVotingStrategy = (
diff --git a/src/hooks/DAO/useCastFreezeVote.ts b/src/hooks/DAO/useCastFreezeVote.ts
index c43874376c..7da10c5e18 100644
--- a/src/hooks/DAO/useCastFreezeVote.ts
+++ b/src/hooks/DAO/useCastFreezeVote.ts
@@ -14,9 +14,7 @@ export const useCastFreezeVote = () => {
   const {
     guardContracts: { freezeVotingContractAddress, freezeVotingType },
   } = useFractal();
-  const {
-    nodeHierarchy: { parentAddress },
-  } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
   const { getUserERC721VotingTokens } = useUserERC721VotingTokens(null, null, false);
 
   const { t } = useTranslation('transaction');
@@ -35,12 +33,14 @@ export const useCastFreezeVote = () => {
             address: freezeVotingContractAddress,
             client: walletClient,
           });
-          return getUserERC721VotingTokens(parentAddress, null).then(tokensInfo => {
-            return freezeERC721VotingContract.write.castFreezeVote([
-              tokensInfo.totalVotingTokenAddresses,
-              tokensInfo.totalVotingTokenIds.map(i => BigInt(i)),
-            ]);
-          });
+          return getUserERC721VotingTokens(subgraphInfo?.parentAddress ?? null, null).then(
+            tokensInfo => {
+              return freezeERC721VotingContract.write.castFreezeVote([
+                tokensInfo.totalVotingTokenAddresses,
+                tokensInfo.totalVotingTokenIds.map(i => BigInt(i)),
+              ]);
+            },
+          );
         },
         pendingMessage: t('pendingCastFreezeVote'),
         failedMessage: t('failedCastFreezeVote'),
@@ -86,7 +86,7 @@ export const useCastFreezeVote = () => {
     freezeVotingContractAddress,
     freezeVotingType,
     getUserERC721VotingTokens,
-    parentAddress,
+    subgraphInfo?.parentAddress,
     t,
     walletClient,
   ]);
diff --git a/src/hooks/DAO/useClawBack.ts b/src/hooks/DAO/useClawBack.ts
index 203cccf2ce..bb3fd002d5 100644
--- a/src/hooks/DAO/useClawBack.ts
+++ b/src/hooks/DAO/useClawBack.ts
@@ -13,13 +13,16 @@ import {
 import { logError } from '../../helpers/errorLogging';
 import useBalancesAPI from '../../providers/App/hooks/useBalancesAPI';
 import { useSafeAPI } from '../../providers/App/hooks/useSafeAPI';
-import { FractalModuleType, DaoInfo } from '../../types';
+import { FractalModuleType, DecentModule } from '../../types';
 import { MOCK_MORALIS_ETH_ADDRESS } from '../../utils/address';
 import { useCanUserCreateProposal } from '../utils/useCanUserSubmitProposal';
 import useSubmitProposal from './proposal/useSubmitProposal';
 
 interface IUseClawBack {
-  childSafeInfo: DaoInfo;
+  childSafeInfo: {
+    daoAddress?: Address;
+    modules: DecentModule[] | null;
+  };
   parentAddress: Address | null;
 }
 
@@ -31,9 +34,9 @@ export default function useClawBack({ childSafeInfo, parentAddress }: IUseClawBa
   const { getTokenBalances } = useBalancesAPI();
 
   const handleClawBack = useCallback(async () => {
-    if (childSafeInfo.safe?.address && parentAddress && safeAPI) {
+    if (childSafeInfo.daoAddress && parentAddress && safeAPI) {
       try {
-        const childSafeTokenBalance = await getTokenBalances(childSafeInfo.safe.address);
+        const childSafeTokenBalance = await getTokenBalances(childSafeInfo.daoAddress);
 
         if (childSafeTokenBalance.error || !childSafeTokenBalance.data) {
           toast.error(t('clawBackBalancesError', { duration: Infinity }));
@@ -48,8 +51,8 @@ export default function useClawBack({ childSafeInfo, parentAddress }: IUseClawBa
         const parentSafeInfo = await safeAPI.getSafeData(parentAddress);
         const canUserCreateProposal = await getCanUserCreateProposal(parentAddress);
 
-        if (canUserCreateProposal && parentAddress && parentSafeInfo) {
-          const fractalModule = childSafeInfo.fractalModules!.find(
+        if (canUserCreateProposal && parentAddress && parentSafeInfo && childSafeInfo.modules) {
+          const fractalModule = childSafeInfo.modules!.find(
             module => module.moduleType === FractalModuleType.FRACTAL,
           );
 
diff --git a/src/hooks/DAO/useDAOData.ts b/src/hooks/DAO/useDAOData.ts
deleted file mode 100644
index fa53c0f83a..0000000000
--- a/src/hooks/DAO/useDAOData.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import { useEffect, useState } from 'react';
-import { Address } from 'viem';
-import { initialGuardState } from '../../providers/App/guard/reducer';
-import { initialGuardContractsState } from '../../providers/App/guardContracts/reducer';
-import { DaoInfo } from '../../types';
-import { DAOData } from '../../types/daoGeneral';
-import { FractalGuardContracts } from '../../types/fractal';
-import { useFractalFreeze } from './loaders/useFractalFreeze';
-import { useFractalGuardContracts } from './loaders/useFractalGuardContracts';
-
-/**
- * A hook for loading guard and freeze guard contract data for the provided
- * FractalNode.
- */
-export function useLoadDAOData(parentSafeAddress: Address | null, fractalNode?: DaoInfo) {
-  const [daoData, setDAOData] = useState<DAOData>();
-  const loadFractalGuardContracts = useFractalGuardContracts({ loadOnMount: false });
-  const loadFractalFreezeGuard = useFractalFreeze({
-    loadOnMount: false,
-    parentSafeAddress,
-  });
-
-  useEffect(() => {
-    const loadDAOData = async () => {
-      if (!fractalNode) {
-        return;
-      }
-      const { safe, fractalModules } = fractalNode;
-
-      if (!safe?.address) {
-        return;
-      }
-
-      let freezeGuardContracts: FractalGuardContracts | undefined = await loadFractalGuardContracts(
-        safe,
-        fractalModules,
-      );
-
-      if (!freezeGuardContracts) {
-        freezeGuardContracts = initialGuardContractsState;
-      }
-      let freezeGuard = await loadFractalFreezeGuard(freezeGuardContracts);
-
-      if (!freezeGuard) {
-        freezeGuard = initialGuardState;
-      }
-
-      setDAOData({
-        safe,
-        fractalModules,
-        freezeGuardContracts: freezeGuardContracts,
-        freezeGuard,
-      });
-    };
-    loadDAOData();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  return { daoData };
-}
diff --git a/src/hooks/DAO/useDeployAzorius.ts b/src/hooks/DAO/useDeployAzorius.ts
index 6b74ab05c5..1d063e3bc7 100644
--- a/src/hooks/DAO/useDeployAzorius.ts
+++ b/src/hooks/DAO/useDeployAzorius.ts
@@ -10,21 +10,21 @@ import MultiSendCallOnlyAbi from '../../assets/abi/MultiSendCallOnly';
 import { SENTINEL_ADDRESS } from '../../constants/common';
 import { DAO_ROUTES } from '../../constants/routes';
 import { TxBuilderFactory } from '../../models/TxBuilderFactory';
+import { useSafeAPI } from '../../providers/App/hooks/useSafeAPI';
 import { useNetworkConfig } from '../../providers/NetworkConfig/NetworkConfigProvider';
 import { useDaoInfoStore } from '../../store/daoInfo/useDaoInfoStore';
 import {
   AzoriusERC20DAO,
   AzoriusERC721DAO,
   FractalModuleType,
-  DaoInfo,
   ProposalExecuteData,
   SubDAO,
   VotingStrategyType,
-  WithError,
 } from '../../types';
 import { useAddressContractType } from '../utils/useAddressContractType';
 import { useCanUserCreateProposal } from '../utils/useCanUserSubmitProposal';
-import { useLoadDAONode } from './loaders/useLoadDAONode';
+import { DecentModule } from './../../types/fractal';
+import { useDecentModules } from './loaders/useDecentModules';
 import useSubmitProposal from './proposal/useSubmitProposal';
 
 const useDeployAzorius = () => {
@@ -53,17 +53,31 @@ const useDeployAzorius = () => {
     },
     addressPrefix,
   } = useNetworkConfig();
-  const {
-    safe,
-    nodeHierarchy: { parentAddress },
-  } = useDaoInfoStore();
+  const { safe, subgraphInfo } = useDaoInfoStore();
 
   const { t } = useTranslation(['transaction', 'proposalMetadata']);
   const { submitProposal } = useSubmitProposal();
   const { canUserCreateProposal } = useCanUserCreateProposal();
 
   const publicClient = usePublicClient();
-  const { loadDao } = useLoadDAONode();
+  const safeApi = useSafeAPI();
+  const lookupModules = useDecentModules();
+
+  const getParentDAOModules = useCallback(
+    async (address: Address) => {
+      try {
+        if (!safeApi) {
+          throw new Error('Safe API not ready');
+        }
+        const safeInfo = await safeApi.getSafeData(address);
+        const modules = await lookupModules(safeInfo.modules);
+        return modules;
+      } catch {
+        return;
+      }
+    },
+    [lookupModules, safeApi],
+  );
   const safeAddress = safe?.address;
 
   const deployAzorius = useCallback(
@@ -84,17 +98,16 @@ const useDeployAzorius = () => {
       let parentStrategyAddress: Address | undefined;
       let parentStrategyType: VotingStrategyType | undefined;
       let attachFractalModule = false;
-      let parentNode: DaoInfo | undefined;
+      let parentModules: DecentModule[];
 
-      if (parentAddress) {
-        const loadedParentNode = await loadDao(parentAddress);
-        const loadingParentNodeError = (loadedParentNode as WithError).error;
-        if (loadingParentNodeError) {
-          toast.error(t(loadingParentNodeError));
+      if (subgraphInfo?.parentAddress) {
+        const loadedParentModule = await getParentDAOModules(subgraphInfo.parentAddress);
+        if (!loadedParentModule) {
+          toast.error(t('errorLoadingParentNode'));
           return;
         } else {
-          parentNode = loadedParentNode as DaoInfo;
-          const parentAzoriusModule = parentNode.fractalModules.find(
+          parentModules = loadedParentModule;
+          const parentAzoriusModule = parentModules.find(
             fractalModule => fractalModule.moduleType === FractalModuleType.AZORIUS,
           );
           if (parentAzoriusModule) {
@@ -122,7 +135,7 @@ const useDeployAzorius = () => {
             }
           }
 
-          const parentFractalModule = parentNode.fractalModules.find(
+          const parentFractalModule = parentModules.find(
             fractalModule => fractalModule.moduleType === FractalModuleType.FRACTAL,
           );
           if (!parentFractalModule) {
@@ -154,7 +167,7 @@ const useDeployAzorius = () => {
         linearVotingErc20MasterCopy,
         linearVotingErc721MasterCopy,
         moduleAzoriusMasterCopy,
-        parentAddress || undefined,
+        subgraphInfo?.parentAddress ?? undefined,
         parentTokenAddress,
       );
 
@@ -216,7 +229,7 @@ const useDeployAzorius = () => {
       canUserCreateProposal,
       safe,
       publicClient,
-      parentAddress,
+      subgraphInfo?.parentAddress,
       compatibilityFallbackHandler,
       votesErc20WrapperMasterCopy,
       votesErc20MasterCopy,
@@ -237,10 +250,10 @@ const useDeployAzorius = () => {
       moduleAzoriusMasterCopy,
       submitProposal,
       t,
-      loadDao,
+      getParentDAOModules,
+      getAddressContractType,
       navigate,
       addressPrefix,
-      getAddressContractType,
     ],
   );
 
diff --git a/src/hooks/utils/useCreateRoles.ts b/src/hooks/utils/useCreateRoles.ts
index f11124af65..9e314e6a33 100644
--- a/src/hooks/utils/useCreateRoles.ts
+++ b/src/hooks/utils/useCreateRoles.ts
@@ -91,7 +91,7 @@ export default function useCreateRoles() {
       moduleAzoriusAddress,
     },
   } = useFractal();
-  const { safe, daoName } = useDaoInfoStore();
+  const { safe, subgraphInfo } = useDaoInfoStore();
   const { hatsTree, hatsTreeId, getHat } = useRolesStore();
   const {
     addressPrefix,
@@ -521,7 +521,7 @@ export default function useCreateRoles() {
       const topHat = {
         details: await uploadHatDescription(
           hatsDetailsBuilder({
-            name: daoName || safeAddress,
+            name: subgraphInfo?.daoName || safeAddress,
             description: '',
           }),
           ipfsClient,
@@ -577,7 +577,7 @@ export default function useCreateRoles() {
       safeAddress,
       getEnableDisableDecentHatsModuleData,
       decentHatsCreationModule,
-      daoName,
+      subgraphInfo?.daoName,
       ipfsClient,
       hatsElectionsEligibilityMasterCopy,
       createHatStructsForNewTreeFromRolesFormValues,
diff --git a/src/hooks/utils/usePageTitle.ts b/src/hooks/utils/usePageTitle.ts
index 40030add5e..18a1069af1 100644
--- a/src/hooks/utils/usePageTitle.ts
+++ b/src/hooks/utils/usePageTitle.ts
@@ -2,14 +2,14 @@ import { useEffect } from 'react';
 import { useDaoInfoStore } from '../../store/daoInfo/useDaoInfoStore';
 
 export const usePageTitle = () => {
-  const { daoName } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
   useEffect(() => {
-    if (daoName) {
-      document.title = `${import.meta.env.VITE_APP_NAME} | ${daoName}`;
+    if (subgraphInfo?.daoName) {
+      document.title = `${import.meta.env.VITE_APP_NAME} | ${subgraphInfo?.daoName}`;
     }
 
     return () => {
       document.title = import.meta.env.VITE_APP_NAME;
     };
-  }, [daoName]);
+  }, [subgraphInfo?.daoName]);
 };
diff --git a/src/hooks/utils/useUpdateSafeData.ts b/src/hooks/utils/useUpdateSafeData.ts
index 9f8722235e..3019ccc083 100644
--- a/src/hooks/utils/useUpdateSafeData.ts
+++ b/src/hooks/utils/useUpdateSafeData.ts
@@ -8,8 +8,7 @@ export const useUpdateSafeData = (safeAddress?: Address) => {
   const safeAPI = useSafeAPI();
   const location = useLocation();
   const prevPathname = useRef(location.pathname);
-
-  const { setSafeInfo } = useDaoInfoStore();
+  const { setSafeInfo, setDecentModules } = useDaoInfoStore();
 
   useEffect(() => {
     if (!safeAPI || !safeAddress) {
@@ -26,5 +25,5 @@ export const useUpdateSafeData = (safeAddress?: Address) => {
       })();
       prevPathname.current = location.pathname;
     }
-  }, [safeAddress, safeAPI, location, setSafeInfo]);
+  }, [safeAddress, safeAPI, location, setSafeInfo, setDecentModules]);
 };
diff --git a/src/hooks/utils/useVotingStrategiesAddresses.ts b/src/hooks/utils/useVotingStrategiesAddresses.ts
index 638c94b51c..9caafd065c 100644
--- a/src/hooks/utils/useVotingStrategiesAddresses.ts
+++ b/src/hooks/utils/useVotingStrategiesAddresses.ts
@@ -5,9 +5,9 @@ import { usePublicClient } from 'wagmi';
 import { SENTINEL_ADDRESS } from '../../constants/common';
 import { useSafeAPI } from '../../providers/App/hooks/useSafeAPI';
 import { useDaoInfoStore } from '../../store/daoInfo/useDaoInfoStore';
-import { FractalModuleData } from '../../types';
+import { DecentModule } from '../../types';
 import { getAzoriusModuleFromModules } from '../../utils';
-import { useFractalModules } from '../DAO/loaders/useFractalModules';
+import { useDecentModules } from '../DAO/loaders/useDecentModules';
 import { useAddressContractType } from './useAddressContractType';
 
 const useVotingStrategiesAddresses = () => {
@@ -15,11 +15,11 @@ const useVotingStrategiesAddresses = () => {
   const publicClient = usePublicClient();
   const safeAPI = useSafeAPI();
   const { getAddressContractType } = useAddressContractType();
-  const lookupModules = useFractalModules();
+  const lookupModules = useDecentModules();
 
   const getVotingStrategies = useCallback(
     async (safeAddress?: Address) => {
-      let azoriusModule: FractalModuleData | undefined;
+      let azoriusModule: DecentModule | undefined;
 
       if (safeAddress) {
         if (!safeAPI) {
@@ -29,7 +29,10 @@ const useVotingStrategiesAddresses = () => {
         const safeModules = await lookupModules(safeInfo.modules);
         azoriusModule = getAzoriusModuleFromModules(safeModules);
       } else {
-        azoriusModule = getAzoriusModuleFromModules(node.fractalModules);
+        if (!node.modules) {
+          throw new Error('DAO modules not ready');
+        }
+        azoriusModule = getAzoriusModuleFromModules(node.modules);
       }
 
       if (!azoriusModule || !publicClient) {
@@ -59,7 +62,7 @@ const useVotingStrategiesAddresses = () => {
       );
       return result;
     },
-    [lookupModules, getAddressContractType, node.fractalModules, publicClient, safeAPI],
+    [lookupModules, getAddressContractType, node.modules, publicClient, safeAPI],
   );
 
   return { getVotingStrategies };
diff --git a/src/i18n/locales/en/transaction.json b/src/i18n/locales/en/transaction.json
index 648d92cb6f..78d63b0c2d 100644
--- a/src/i18n/locales/en/transaction.json
+++ b/src/i18n/locales/en/transaction.json
@@ -19,5 +19,6 @@
   "failedTokenClaim": "Failed to claim {{ symbol }}",
   "successTokenClaim": "You have successfully claimed {{ amount }} {{ symbol }}",
   "snapshotRecastVoteHelper": "You can still change your vote until the voting period ends.",
-  "modifyGovernanceSetAzoriusProposalPendingMessage": "Submitting proposal to modify governance..."
+  "modifyGovernanceSetAzoriusProposalPendingMessage": "Submitting proposal to modify governance...",
+  "errorLoadingParentNode": "Error loading parent"
 }
diff --git a/src/models/DaoTxBuilder.ts b/src/models/DaoTxBuilder.ts
index 9d69c1fe82..98a70f7a8c 100644
--- a/src/models/DaoTxBuilder.ts
+++ b/src/models/DaoTxBuilder.ts
@@ -12,7 +12,7 @@ import {
 } from '../types';
 import { BaseTxBuilder } from './BaseTxBuilder';
 import { TxBuilderFactory } from './TxBuilderFactory';
-import { fractalModuleData, FractalModuleData } from './helpers/fractalModuleData';
+import { fractalModuleData, DecentModule } from './helpers/fractalModuleData';
 
 export class DaoTxBuilder extends BaseTxBuilder {
   private readonly saltNum;
@@ -235,7 +235,7 @@ export class DaoTxBuilder extends BaseTxBuilder {
   //
 
   private setFractalModuleTxs(): void {
-    const { enableFractalModuleTx, deployFractalModuleTx }: FractalModuleData = fractalModuleData(
+    const { enableFractalModuleTx, deployFractalModuleTx }: DecentModule = fractalModuleData(
       this.moduleFractalMasterCopy,
       this.zodiacModuleProxyFactory,
       this.safeContractAddress,
diff --git a/src/models/helpers/fractalModuleData.ts b/src/models/helpers/fractalModuleData.ts
index 54c6898c7a..a03a4424ac 100644
--- a/src/models/helpers/fractalModuleData.ts
+++ b/src/models/helpers/fractalModuleData.ts
@@ -14,7 +14,7 @@ import { buildContractCall } from '../../helpers/crypto';
 import { SafeTransaction } from '../../types';
 import { generateContractByteCodeLinear, generateSalt } from './utils';
 
-export interface FractalModuleData {
+export interface DecentModule {
   predictedFractalModuleAddress: string;
   deployFractalModuleTx: SafeTransaction;
   enableFractalModuleTx: SafeTransaction;
@@ -25,8 +25,8 @@ export const fractalModuleData = (
   moduleProxyFactoryAddress: Address,
   safeAddress: Address,
   saltNum: bigint,
-  parentAddress?: Address,
-): FractalModuleData => {
+  parentAddress?: Address | null,
+): DecentModule => {
   const fractalModuleCalldata = encodeFunctionData({
     abi: abis.FractalModule,
     functionName: 'setUp',
diff --git a/src/pages/dao/SafeController.tsx b/src/pages/dao/SafeController.tsx
index 0d7dc3285a..2f3c92f688 100644
--- a/src/pages/dao/SafeController.tsx
+++ b/src/pages/dao/SafeController.tsx
@@ -26,9 +26,7 @@ export function SafeController() {
   useTemporaryProposals();
   useAutomaticSwitchChain({ addressPrefix });
 
-  const {
-    nodeHierarchy: { parentAddress },
-  } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
 
   const { errorLoading } = useFractalNode({
     addressPrefix,
@@ -37,7 +35,7 @@ export function SafeController() {
 
   useGovernanceContracts();
   useFractalGuardContracts({});
-  useFractalFreeze({ parentSafeAddress: parentAddress });
+  useFractalFreeze({ parentSafeAddress: subgraphInfo?.parentAddress ?? null });
   useFractalGovernance();
   useDecentTreasury();
   useERC20Claim();
diff --git a/src/pages/dao/edit/governance/SafeEditGovernancePage.tsx b/src/pages/dao/edit/governance/SafeEditGovernancePage.tsx
index 17df5378d8..beea9d107c 100644
--- a/src/pages/dao/edit/governance/SafeEditGovernancePage.tsx
+++ b/src/pages/dao/edit/governance/SafeEditGovernancePage.tsx
@@ -32,7 +32,7 @@ export function SafeEditGovernancePage() {
     governance: { type },
   } = useFractal();
   const user = useAccount();
-  const { safe, daoName, daoSnapshotENS } = useDaoInfoStore();
+  const { safe, subgraphInfo } = useDaoInfoStore();
   const { addressPrefix } = useNetworkConfig();
   const { t } = useTranslation(['daoEdit', 'common', 'breadcrumbs']);
   const navigate = useNavigate();
@@ -47,15 +47,15 @@ export function SafeEditGovernancePage() {
   }
 
   const handleDeployAzorius: DAOTrigger = (daoData, customNonce) => {
-    const shouldSetName = daoData.daoName !== daoName;
+    const shouldSetName = daoData.daoName !== subgraphInfo?.daoName;
 
     // We will add a set snapshot tx, if the current safe's snapshot is different from the new one, AND
     //   EITHER:
     //      - the current snapshot is not null, OR
     //      - the current snapshot WAS indeed null (for a safe that does not already have an ENS set), but the new snapshot is not empty
     const shouldSetSnapshot =
-      daoSnapshotENS !== daoData.snapshotENS &&
-      (daoSnapshotENS !== null || daoData.snapshotENS !== '');
+      subgraphInfo?.daoSnapshotENS !== daoData.snapshotENS &&
+      (subgraphInfo?.daoSnapshotENS !== null || daoData.snapshotENS !== '');
 
     deployAzorius(daoData as AzoriusERC20DAO | AzoriusERC721DAO | SubDAO, customNonce, {
       shouldSetName,
diff --git a/src/pages/dao/hierarchy/SafeHierarchyPage.tsx b/src/pages/dao/hierarchy/SafeHierarchyPage.tsx
index 102f778581..21e66afdc4 100644
--- a/src/pages/dao/hierarchy/SafeHierarchyPage.tsx
+++ b/src/pages/dao/hierarchy/SafeHierarchyPage.tsx
@@ -14,12 +14,7 @@ export function SafeHierarchyPage() {
     amplitude.track(analyticsEvents.HierarchyPageOpened);
   }, []);
 
-  const {
-    safe,
-    daoName,
-    nodeHierarchy: { parentAddress },
-    isHierarchyLoaded,
-  } = useDaoInfoStore();
+  const { safe, subgraphInfo } = useDaoInfoStore();
 
   const { t } = useTranslation('breadcrumbs');
 
@@ -27,13 +22,14 @@ export function SafeHierarchyPage() {
 
   const safeAddress = safe?.address;
 
-  if (!safeAddress || !isHierarchyLoaded) {
+  if (!safeAddress || !subgraphInfo) {
     return (
       <Center minH={`calc(100vh - ${HEADER_HEIGHT})`}>
         <BarLoader />
       </Center>
     );
   }
+  const { daoName, parentAddress } = subgraphInfo;
 
   return (
     <Box>
diff --git a/src/pages/dao/settings/SafeSettingsPage.tsx b/src/pages/dao/settings/SafeSettingsPage.tsx
index 92b3299c6c..85aaa94a03 100644
--- a/src/pages/dao/settings/SafeSettingsPage.tsx
+++ b/src/pages/dao/settings/SafeSettingsPage.tsx
@@ -7,7 +7,7 @@ import { useDaoInfoStore } from '../../../store/daoInfo/useDaoInfoStore';
 
 export function SafeSettingsPage() {
   const { t } = useTranslation(['settings']);
-  const { daoName } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
   const location = useLocation();
   const paths = location.pathname.split('/');
   const isMobile = useBreakpointValue({ base: true, md: false });
@@ -23,7 +23,7 @@ export function SafeSettingsPage() {
               path: '',
             },
           ]}
-          title={t('settingsPageTitle', { daoName })}
+          title={t('settingsPageTitle', { daoName: subgraphInfo?.daoName })}
         />
       )}
       <Flex flexDirection={{ base: 'column', md: 'row' }}>
diff --git a/src/pages/dao/settings/general/SafeGeneralSettingsPage.tsx b/src/pages/dao/settings/general/SafeGeneralSettingsPage.tsx
index 48fb440b17..03076d8e86 100644
--- a/src/pages/dao/settings/general/SafeGeneralSettingsPage.tsx
+++ b/src/pages/dao/settings/general/SafeGeneralSettingsPage.tsx
@@ -27,7 +27,7 @@ export function SafeGeneralSettingsPage() {
 
   const { submitProposal } = useSubmitProposal();
   const { canUserCreateProposal } = useCanUserCreateProposal();
-  const { daoName, daoSnapshotENS, safe } = useDaoInfoStore();
+  const { subgraphInfo, safe } = useDaoInfoStore();
   const {
     addressPrefix,
     contracts: { keyValuePairs },
@@ -36,19 +36,26 @@ export function SafeGeneralSettingsPage() {
   const safeAddress = safe?.address;
 
   useEffect(() => {
-    if (daoName && safeAddress && createAccountSubstring(safeAddress) !== daoName) {
-      setName(daoName);
+    if (
+      subgraphInfo?.daoName &&
+      safeAddress &&
+      createAccountSubstring(safeAddress) !== subgraphInfo?.daoName
+    ) {
+      setName(subgraphInfo.daoName);
     }
 
-    if (daoSnapshotENS) {
-      setSnapshotENS(daoSnapshotENS);
+    if (subgraphInfo?.daoSnapshotENS) {
+      setSnapshotENS(subgraphInfo?.daoSnapshotENS);
     }
-  }, [daoName, daoSnapshotENS, safeAddress]);
+  }, [subgraphInfo?.daoName, subgraphInfo?.daoSnapshotENS, safeAddress]);
 
   const handleSnapshotENSChange: ChangeEventHandler<HTMLInputElement> = e => {
     const lowerCasedValue = e.target.value.toLowerCase();
     setSnapshotENS(lowerCasedValue);
-    if (validateENSName(lowerCasedValue) || (e.target.value === '' && daoSnapshotENS)) {
+    if (
+      validateENSName(lowerCasedValue) ||
+      (e.target.value === '' && subgraphInfo?.daoSnapshotENS)
+    ) {
       setSnapshotENSValid(true);
     } else {
       setSnapshotENSValid(false);
@@ -61,8 +68,8 @@ export function SafeGeneralSettingsPage() {
     }
   };
 
-  const nameChanged = name !== daoName;
-  const snapshotChanged = snapshotENSValid && snapshotENS !== daoSnapshotENS;
+  const nameChanged = name !== subgraphInfo?.daoName;
+  const snapshotChanged = snapshotENSValid && snapshotENS !== subgraphInfo?.daoSnapshotENS;
 
   const handleEditGeneralGovernance = () => {
     const changeTitles = [];
@@ -158,7 +165,9 @@ export function SafeGeneralSettingsPage() {
             gap="1rem"
           >
             <Text textStyle="display-lg">
-              {daoSnapshotENS ? t('daoMetadataSnapshot') : t('daoMetadataConnectSnapshot')}
+              {subgraphInfo?.daoSnapshotENS
+                ? t('daoMetadataSnapshot')
+                : t('daoMetadataConnectSnapshot')}
             </Text>
             <InputComponent
               isRequired={false}
diff --git a/src/pages/dao/settings/modules-and-guard/SafeModulesSettingsPage.tsx b/src/pages/dao/settings/modules-and-guard/SafeModulesSettingsPage.tsx
index 87301d679f..c31738079a 100644
--- a/src/pages/dao/settings/modules-and-guard/SafeModulesSettingsPage.tsx
+++ b/src/pages/dao/settings/modules-and-guard/SafeModulesSettingsPage.tsx
@@ -19,7 +19,7 @@ export function SafeModulesSettingsPage() {
   const {
     guardContracts: { freezeGuardContractAddress, freezeVotingContractAddress },
   } = useFractal();
-  const { fractalModules, isModulesLoaded, safe } = useDaoInfoStore();
+  const { modules, safe } = useDaoInfoStore();
 
   return (
     <>
@@ -42,9 +42,9 @@ export function SafeModulesSettingsPage() {
             w={{ base: 'calc(100% + 1.5rem)', md: 'calc(100% + 3rem)' }}
             mx={{ base: '-0.75rem', md: '-1.5rem' }}
           />
-          {isModulesLoaded ? (
-            fractalModules.length > 0 ? (
-              fractalModules.map(({ moduleAddress, moduleType }) => {
+          {modules !== null ? (
+            modules.length > 0 ? (
+              modules.map(({ moduleAddress, moduleType }) => {
                 const moduleHelper =
                   moduleType === FractalModuleType.AZORIUS
                     ? ' (Azorius Module)'
diff --git a/src/pages/dao/treasury/SafeTreasuryPage.tsx b/src/pages/dao/treasury/SafeTreasuryPage.tsx
index e0641afcad..0d7896d5bb 100644
--- a/src/pages/dao/treasury/SafeTreasuryPage.tsx
+++ b/src/pages/dao/treasury/SafeTreasuryPage.tsx
@@ -26,7 +26,7 @@ export function SafeTreasuryPage() {
   const {
     treasury: { assetsFungible, transfers },
   } = useFractal();
-  const { daoName } = useDaoInfoStore();
+  const { subgraphInfo } = useDaoInfoStore();
   const [shownTransactions, setShownTransactions] = useState(20);
   const { t } = useTranslation(['treasury', 'modals']);
   const { canUserCreateProposal } = useCanUserCreateProposal();
@@ -65,7 +65,7 @@ export function SafeTreasuryPage() {
       <PageHeader
         title={t('headerTitle', {
           ns: 'breadcrumbs',
-          daoName,
+          daoName: subgraphInfo?.daoName,
           subject: t('treasury', { ns: 'breadcrumbs' }),
         })}
         showSafeAddress
diff --git a/src/providers/App/hooks/useSafeAPI.ts b/src/providers/App/hooks/useSafeAPI.ts
index 16f4636ae3..014e08dcaa 100644
--- a/src/providers/App/hooks/useSafeAPI.ts
+++ b/src/providers/App/hooks/useSafeAPI.ts
@@ -90,8 +90,6 @@ class EnhancedSafeApiKit extends SafeApiKit {
     const safeInfo = {
       ...safeInfoResponse,
       nextNonce,
-      address: getAddress(safeInfoResponse.address),
-      guard: getAddress(safeInfoResponse.guard),
     };
     return safeInfo;
   }
diff --git a/src/store/daoInfo/useDaoInfoStore.ts b/src/store/daoInfo/useDaoInfoStore.ts
index 5a46f0988e..8ed99fdd50 100644
--- a/src/store/daoInfo/useDaoInfoStore.ts
+++ b/src/store/daoInfo/useDaoInfoStore.ts
@@ -1,39 +1,54 @@
+import { getAddress } from 'viem';
 import { create } from 'zustand';
-import { DaoInfo, SafeWithNextNonce } from '../../types';
+import { DAOSubgraph, DecentModule, IDAO, SafeWithNextNonce } from '../../types';
 
-type DAOInfoWithoutLoaders = Omit<DaoInfo, 'isModulesLoaded' | 'isHierarchyLoaded'>;
-
-export const initialDaoInfoStore: DaoInfo = {
-  daoName: null,
+export const initialDaoInfoStore: IDAO = {
   safe: null,
-  fractalModules: [],
-  nodeHierarchy: {
-    parentAddress: null,
-    childNodes: [],
-  },
-  isHierarchyLoaded: false,
-  isModulesLoaded: false,
+  subgraphInfo: null,
+  modules: null,
 };
-export interface DaoInfoStore extends DaoInfo {
-  setSafeInfo: (safeWithNonce: SafeWithNextNonce) => void;
-  setDaoInfo: (daoInfo: DAOInfoWithoutLoaders) => void;
+export interface DaoInfoStore extends IDAO {
+  setSafeInfo: (safe: SafeWithNextNonce) => void;
+  setDaoInfo: (daoInfo: DAOSubgraph) => void;
+  setDecentModules: (modules: DecentModule[]) => void;
   updateDaoName: (newDaoName: string) => void;
   resetDaoInfoStore: () => void;
 }
 
 export const useDaoInfoStore = create<DaoInfoStore>()(set => ({
   ...initialDaoInfoStore,
-  setSafeInfo: (safeWithNonce: SafeWithNextNonce) => {
-    set({ safe: safeWithNonce });
+  setSafeInfo: (safe: SafeWithNextNonce) => {
+    const { address, owners, nonce, nextNonce, threshold, modules, guard } = safe;
+    set({
+      safe: {
+        owners: owners.map(getAddress),
+        modulesAddresses: modules.map(getAddress),
+        guard: getAddress(guard),
+        address: getAddress(address),
+        nextNonce,
+        threshold,
+        nonce,
+      },
+    });
   },
 
   // called by subgraph data flow
-  setDaoInfo: (daoInfo: DAOInfoWithoutLoaders) => {
-    set({ ...daoInfo, isHierarchyLoaded: true, isModulesLoaded: true });
+  setDaoInfo: (subgraphInfo: DAOSubgraph) => {
+    set({ subgraphInfo });
   },
 
+  setDecentModules: (modules: DecentModule[]) => {
+    set({ modules });
+  },
   updateDaoName: (newDaoName: string) => {
-    set({ daoName: newDaoName });
+    set(state => {
+      if (!state.subgraphInfo) {
+        throw new Error('Subgraph info is not set');
+      }
+      return {
+        subgraphInfo: { ...state.subgraphInfo, daoName: newDaoName },
+      };
+    });
   },
   resetDaoInfoStore: () => set(initialDaoInfoStore),
 }));
diff --git a/src/types/daoGeneral.ts b/src/types/daoGeneral.ts
index 140970ac08..b81d287a22 100644
--- a/src/types/daoGeneral.ts
+++ b/src/types/daoGeneral.ts
@@ -1,38 +1,3 @@
-import {
-  FractalModuleData,
-  FractalGuardContracts,
-  FreezeGuard,
-  SafeWithNextNonce,
-} from './fractal';
-
-export type DAOData = {
-  safe: SafeWithNextNonce;
-  fractalModules?: FractalModuleData[];
-  freezeGuardContracts: FractalGuardContracts;
-  freezeGuard: FreezeGuard;
-};
-
-export type DAOMetadata = {
-  address: string;
-  logo: string;
-  headerBackground: string;
-  bodyBackground?: string;
-  links: {
-    title: string;
-    url: string;
-  }[];
-  sections: {
-    title: string;
-    content: string;
-    background?: string;
-    link?: {
-      url: string;
-      text: string;
-      position: 'start' | 'end';
-    };
-  }[];
-};
-
 export enum DAOState {
   freezeInit = 'stateFreezeInit',
   frozen = 'stateFrozen',
diff --git a/src/types/fractal.ts b/src/types/fractal.ts
index ad96d0d7ae..19fd854391 100644
--- a/src/types/fractal.ts
+++ b/src/types/fractal.ts
@@ -124,6 +124,42 @@ export enum FractalProposalState {
   CLOSED = 'stateClosed',
 }
 
+export type GnosisSafe = {
+  // replaces SafeInfoResponseWithGuard and SafeWithNextNonce
+  address: Address;
+  owners: Address[];
+  nonce: number;
+  nextNonce: number;
+  threshold: number;
+  modulesAddresses: Address[];
+  guard: Address | null;
+};
+
+export interface DAOSubgraph {
+  // replaces Part of DaoInfo
+  daoName: string | null;
+  parentAddress: Address | null;
+  childAddresses: Address[];
+  daoSnapshotENS: string | null;
+  proposalTemplatesHash: string | null;
+}
+
+// @todo should we add other Decent Module types here?
+export enum DecentModuleType {
+  // replaces FractalModuleType
+  AZORIUS, // Token Module
+  FRACTAL, // CHILD GOVERNANCE MODULE
+  UNKNOWN, // NON-DECENT MODULE
+}
+
+// @todo better typing here, SUBGRAPH has DAO type name,
+export interface IDAO {
+  // replaces DaoInfo
+  safe: GnosisSafe | null;
+  subgraphInfo: DAOSubgraph | null;
+  modules: DecentModule[] | null;
+}
+
 export interface GovernanceActivity extends ActivityBase {
   state: FractalProposalState | null;
   proposalId: string;
@@ -184,7 +220,7 @@ export interface FractalGovernanceContracts {
   isLoaded: boolean;
 }
 
-export type SafeWithNextNonce = SafeInfoResponseWithGuard & { address: Address; nextNonce: number };
+export type SafeWithNextNonce = SafeInfoResponseWithGuard & { nextNonce: number };
 
 // @dev Information retreived from subgraph
 interface SubgraphDAOInfo {
@@ -198,23 +234,22 @@ interface SubgraphDAOInfo {
 // @dev Information retreived from Safe
 export interface DaoInfo extends SubgraphDAOInfo {
   safe: SafeWithNextNonce | null;
-  fractalModules: FractalModuleData[];
+  fractalModules: DecentModule[];
   isModulesLoaded?: boolean;
 }
-
+export type DaoHierarchyStrategyType = 'ERC-20' | 'ERC-721' | 'MULTISIG';
 export interface DaoHierarchyInfo {
-  daoName: string | null;
-  nodeHierarchy: {
-    parentAddress: Address | null;
-    childNodes: {
-      safeAddress: Address;
-    }[];
-  };
   safeAddress: Address;
-  daoSnapshotENS?: string;
+  daoName: string | null;
+  daoSnapshotENS: string | null;
+  parentAddress: Address | null;
+  childAddresses: Address[];
+  proposalTemplatesHash: string | null;
+  modules: DecentModule[];
+  votingStrategies: DaoHierarchyStrategyType[];
 }
 
-export interface FractalModuleData {
+export interface DecentModule {
   moduleAddress: Address;
   moduleType: FractalModuleType;
 }
@@ -224,6 +259,7 @@ export enum FractalModuleType {
   FRACTAL,
   UNKNOWN,
 }
+
 export interface FractalGuardContracts {
   freezeGuardContractAddress?: Address;
   freezeVotingContractAddress?: Address;
diff --git a/src/types/safeGlobal.ts b/src/types/safeGlobal.ts
index d4e7cea452..aa91154508 100644
--- a/src/types/safeGlobal.ts
+++ b/src/types/safeGlobal.ts
@@ -1,5 +1,4 @@
 import { SafeInfoResponse } from '@safe-global/api-kit';
-import { Address } from 'viem';
 
 export declare enum Operation {
   CALL = 0,
@@ -30,6 +29,5 @@ export declare type DataDecoded = {
 
 export type SafeInfoResponseWithGuard = SafeInfoResponse & {
   nextNonce: number;
-  guard?: Address;
-  address: Address;
+  guard: string;
 };
diff --git a/src/utils/azorius.ts b/src/utils/azorius.ts
index 660715c3cc..988bb13fe9 100644
--- a/src/utils/azorius.ts
+++ b/src/utils/azorius.ts
@@ -16,7 +16,7 @@ import {
   DataDecoded,
   DecodedTransaction,
   ERC721ProposalVote,
-  FractalModuleData,
+  DecentModule,
   FractalModuleType,
   FractalProposalState,
   MetaTransaction,
@@ -321,7 +321,7 @@ export const parseDecodedData = (
   return Array.from(eventTransactionMap.values());
 };
 
-export function getAzoriusModuleFromModules(modules: FractalModuleData[]) {
+export function getAzoriusModuleFromModules(modules: DecentModule[]) {
   return modules.find(module => module.moduleType === FractalModuleType.AZORIUS);
 }