[Issue | No Issue assigned] Various loading and error handling cleanup

src/hooks/DAO/loaders/useGovernanceContracts.ts

@@ -6,6 +6,7 @@ import LockReleaseAbi from '../../../assets/abi/LockRelease';
 import { useFractal } from '../../../providers/App/AppProvider';
 import { GovernanceContractAction } from '../../../providers/App/governanceContracts/action';
 import { useDaoInfoStore } from '../../../store/daoInfo/useDaoInfoStore';
+import { DecentModule } from '../../../types';
 import { getAzoriusModuleFromModules } from '../../../utils';
 import { useAddressContractType } from '../../utils/useAddressContractType';
 import useVotingStrategyAddress from '../../utils/useVotingStrategiesAddresses';
@@ -23,114 +24,119 @@ export const useGovernanceContracts = () => {
 
   const safeAddress = safe?.address;
 
-  const loadGovernanceContracts = useCallback(async () => {
-    const azoriusModule = getAzoriusModuleFromModules(modules ?? []);
+  const loadGovernanceContracts = useCallback(
+    async (daoModules: DecentModule[]) => {
+      const azoriusModule = getAzoriusModuleFromModules(daoModules);
 
-    const votingStrategies = await getVotingStrategies();
-
-    if (!azoriusModule || !votingStrategies) {
-      action.dispatch({
-        type: GovernanceContractAction.SET_GOVERNANCE_CONTRACT_ADDRESSES,
-        payload: {},
-      });
-      return;
-    }
-
-    if (!publicClient) {
-      throw new Error('Public Client is not set!');
-    }
-
-    let linearVotingErc20Address: Address | undefined;
-    let linearVotingErc721Address: Address | undefined;
-    let linearVotingErc20WithHatsWhitelistingAddress: Address | undefined;
-    let linearVotingErc721WithHatsWhitelistingAddress: Address | undefined;
-    let votesTokenAddress: Address | undefined;
-    let lockReleaseAddress: Address | undefined;
-
-    const setGovTokenAddress = async (erc20VotingStrategyAddress: Address) => {
-      if (votesTokenAddress) {
+      const votingStrategies = await getVotingStrategies();
+      if (!azoriusModule || !votingStrategies) {
+        action.dispatch({
+          type: GovernanceContractAction.SET_GOVERNANCE_CONTRACT_ADDRESSES,
+          payload: {},
+        });
         return;
       }
-      const ozLinearVotingContract = getContract({
-        abi: abis.LinearERC20Voting,
-        address: erc20VotingStrategyAddress,
-        client: publicClient,
-      });
 
-      const govTokenAddress = await ozLinearVotingContract.read.governanceToken();
-      // govTokenAddress might be either
-      // - a valid VotesERC20 contract
-      // - a valid LockRelease contract
-      // - or none of these which is against business logic
+      if (!publicClient) {
+        throw new Error('Public Client is not set!');
+      }
 
-      const { isVotesErc20 } = await getAddressContractType(govTokenAddress);
+      let linearVotingErc20Address: Address | undefined;
+      let linearVotingErc721Address: Address | undefined;
+      let linearVotingErc20WithHatsWhitelistingAddress: Address | undefined;
+      let linearVotingErc721WithHatsWhitelistingAddress: Address | undefined;
+      let votesTokenAddress: Address | undefined;
+      let lockReleaseAddress: Address | undefined;
 
-      if (isVotesErc20) {
-        votesTokenAddress = govTokenAddress;
-      } else {
-        const possibleLockRelease = getContract({
-          address: govTokenAddress,
-          abi: LockReleaseAbi,
-          client: { public: publicClient },
+      const setGovTokenAddress = async (erc20VotingStrategyAddress: Address) => {
+        if (votesTokenAddress) {
+          return;
+        }
+        const ozLinearVotingContract = getContract({
+          abi: abis.LinearERC20Voting,
+          address: erc20VotingStrategyAddress,
+          client: publicClient,
         });
 
-        try {
-          const lockedTokenAddress = await possibleLockRelease.read.token();
-          lockReleaseAddress = govTokenAddress;
-          votesTokenAddress = lockedTokenAddress;
-        } catch {
-          throw new Error('Unknown governance token type');
+        const govTokenAddress = await ozLinearVotingContract.read.governanceToken();
+        // govTokenAddress might be either
+        // - a valid VotesERC20 contract
+        // - a valid LockRelease contract
+        // - or none of these which is against business logic
+
+        const { isVotesErc20 } = await getAddressContractType(govTokenAddress);
+
+        if (isVotesErc20) {
+          votesTokenAddress = govTokenAddress;
+        } else {
+          const possibleLockRelease = getContract({
+            address: govTokenAddress,
+            abi: LockReleaseAbi,
+            client: { public: publicClient },
+          });
+
+          try {
+            votesTokenAddress = await possibleLockRelease.read.token();
+            lockReleaseAddress = govTokenAddress;
+          } catch {
+            throw new Error('Unknown governance token type');
+          }
         }
+      };
+
+      await Promise.all(
+        votingStrategies.map(async votingStrategy => {
+          const {
+            strategyAddress,
+            isLinearVotingErc20,
+            isLinearVotingErc721,
+            isLinearVotingErc20WithHatsProposalCreation,
+            isLinearVotingErc721WithHatsProposalCreation,
+          } = votingStrategy;
+          if (isLinearVotingErc20) {
+            linearVotingErc20Address = strategyAddress;
+            await setGovTokenAddress(strategyAddress);
+          } else if (isLinearVotingErc721) {
+            linearVotingErc721Address = strategyAddress;
+          } else if (isLinearVotingErc20WithHatsProposalCreation) {
+            linearVotingErc20WithHatsWhitelistingAddress = strategyAddress;
+            await setGovTokenAddress(strategyAddress);
+          } else if (isLinearVotingErc721WithHatsProposalCreation) {
+            linearVotingErc721WithHatsWhitelistingAddress = strategyAddress;
+          }
+        }),
+      );
+
+      if (
+        linearVotingErc20Address ||
+        linearVotingErc20WithHatsWhitelistingAddress ||
+        linearVotingErc721Address ||
+        linearVotingErc721WithHatsWhitelistingAddress
+      ) {
+        action.dispatch({
+          type: GovernanceContractAction.SET_GOVERNANCE_CONTRACT_ADDRESSES,
+          payload: {
+            linearVotingErc20Address,
+            linearVotingErc20WithHatsWhitelistingAddress,
+            linearVotingErc721Address,
+            linearVotingErc721WithHatsWhitelistingAddress,
+            votesTokenAddress,
+            lockReleaseAddress,
+            moduleAzoriusAddress: azoriusModule.moduleAddress,
+          },
+        });
       }
-    };
-
-    await Promise.all(
-      votingStrategies.map(async votingStrategy => {
-        const {
-          strategyAddress,
-          isLinearVotingErc20,
-          isLinearVotingErc721,
-          isLinearVotingErc20WithHatsProposalCreation,
-          isLinearVotingErc721WithHatsProposalCreation,
-        } = votingStrategy;
-        if (isLinearVotingErc20) {
-          linearVotingErc20Address = strategyAddress;
-          await setGovTokenAddress(strategyAddress);
-        } else if (isLinearVotingErc721) {
-          linearVotingErc721Address = strategyAddress;
-        } else if (isLinearVotingErc20WithHatsProposalCreation) {
-          linearVotingErc20WithHatsWhitelistingAddress = strategyAddress;
-          await setGovTokenAddress(strategyAddress);
-        } else if (isLinearVotingErc721WithHatsProposalCreation) {
-          linearVotingErc721WithHatsWhitelistingAddress = strategyAddress;
-        }
-      }),
-    );
+    },
+    [action, getVotingStrategies, publicClient, getAddressContractType],
+  );
 
+  useEffect(() => {
     if (
-      linearVotingErc20Address ||
-      linearVotingErc20WithHatsWhitelistingAddress ||
-      linearVotingErc721Address ||
-      linearVotingErc721WithHatsWhitelistingAddress
+      safeAddress !== undefined &&
+      currentValidAddress.current !== safeAddress &&
+      modules !== null
     ) {
-      action.dispatch({
-        type: GovernanceContractAction.SET_GOVERNANCE_CONTRACT_ADDRESSES,
-        payload: {
-          linearVotingErc20Address,
-          linearVotingErc20WithHatsWhitelistingAddress,
-          linearVotingErc721Address,
-          linearVotingErc721WithHatsWhitelistingAddress,
-          votesTokenAddress,
-          lockReleaseAddress,
-          moduleAzoriusAddress: azoriusModule.moduleAddress,
-        },
-      });
-    }
-  }, [action, modules, getVotingStrategies, publicClient, getAddressContractType]);
-
-  useEffect(() => {
-    if (currentValidAddress.current !== safeAddress && modules !== null) {
-      loadGovernanceContracts();
+      loadGovernanceContracts(modules);
       currentValidAddress.current = safeAddress;
     }
     if (!safeAddress) {

src/hooks/DAO/loaders/useHatsTree.ts

@@ -10,35 +10,30 @@ import { SablierV2LockupLinearAbi } from '../../../assets/abi/SablierV2LockupLin
 import { useFractal } from '../../../providers/App/AppProvider';
 import useIPFSClient from '../../../providers/App/hooks/useIPFSClient';
 import { useNetworkConfig } from '../../../providers/NetworkConfig/NetworkConfigProvider';
-import { useDaoInfoStore } from '../../../store/daoInfo/useDaoInfoStore';
 import { DecentHatsError } from '../../../store/roles/rolesStoreUtils';
 import { useRolesStore } from '../../../store/roles/useRolesStore';
 import { SablierPayment } from '../../../types/roles';
 import { convertStreamIdToBigInt } from '../../streams/useCreateSablierStream';
 import { CacheExpiry, CacheKeys } from '../../utils/cache/cacheDefaults';
 import { getValue, setValue } from '../../utils/cache/useLocalStorage';
-import { useParseSafeAddress } from '../useParseSafeAddress';
 
 const hatsSubgraphClient = new HatsSubgraphClient({});
 
 const useHatsTree = () => {
   const { t } = useTranslation('roles');
-  const { safeAddress } = useParseSafeAddress();
   const {
     governanceContracts: {
       linearVotingErc20WithHatsWhitelistingAddress,
       linearVotingErc721WithHatsWhitelistingAddress,
     },
   } = useFractal();
-  const { safe } = useDaoInfoStore();
   const {
     hatsTreeId,
     contextChainId,
     hatsTree,
     streamsFetched,
     setHatsTree,
     updateRolesWithStreams,
-    resetHatsStore,
   } = useRolesStore();
 
   const ipfsClient = useIPFSClient();
@@ -301,12 +296,6 @@ const useHatsTree = () => {
 
     getHatsStreams();
   }, [hatsTree, updateRolesWithStreams, getPaymentStreams, streamsFetched]);
-
-  useEffect(() => {
-    if (safeAddress && safe?.address && safeAddress !== safe.address && hatsTree) {
-      resetHatsStore();
-    }
-  }, [resetHatsStore, safeAddress, safe?.address, hatsTree]);
 };
 
 export { useHatsTree };

src/hooks/DAO/useKeyValuePairs.ts

@@ -1,7 +1,6 @@
 import { abis } from '@fractal-framework/fractal-contracts';
 import { hatIdToTreeId } from '@hatsprotocol/sdk-v1-core';
 import { useEffect } from 'react';
-import { useSearchParams } from 'react-router-dom';
 import { Address, GetContractEventsReturnType, getContract } from 'viem';
 import { usePublicClient } from 'wagmi';
 import { logError } from '../../helpers/errorLogging';
@@ -98,15 +97,12 @@ const useKeyValuePairs = () => {
     chain,
     contracts: { keyValuePairs, sablierV2LockupLinear },
   } = useNetworkConfig();
-  const { setHatKeyValuePairData } = useRolesStore();
-  const [searchParams] = useSearchParams();
+  const { setHatKeyValuePairData, resetHatsStore } = useRolesStore();
 
   const safeAddress = node.safe?.address;
 
   useEffect(() => {
-    const safeParam = searchParams.get('dao');
-
-    if (!publicClient || !safeAddress || safeAddress !== safeParam?.split(':')[1]) {
+    if (!safeAddress || !publicClient) {
       return;
     }
 
@@ -160,10 +156,17 @@ const useKeyValuePairs = () => {
     keyValuePairs,
     safeAddress,
     publicClient,
-    searchParams,
     setHatKeyValuePairData,
     sablierV2LockupLinear,
   ]);
+
+  useEffect(() => {
+    if (!safeAddress) {
+      return;
+    }
+
+    resetHatsStore();
+  }, [resetHatsStore, safeAddress]);
 };
 
 export { useKeyValuePairs };

src/hooks/utils/useCreateRoles.ts

@@ -915,6 +915,9 @@ export default function useCreateRoles() {
           throw new Error('Cannot prepare transactions for edited role without smart address');
         }
         const newPredictedHatSmartAccount = await predictSmartAccount(BigInt(formHat.id));
+        if (!newPredictedHatSmartAccount) {
+          throw new Error('Cannot predict smart account');
+        }
         const newStreamTxData = createBatchLinearStreamCreationTx(
           newStreamsOnHat.map(stream => ({ ...stream, recipient: newPredictedHatSmartAccount })),
         );