Remove azorius typechain

src/components/pages/DaoHierarchy/useFetchNodes.tsx

@@ -1,7 +1,9 @@
 import { useQuery } from '@apollo/client';
 import { useCallback, useEffect, useState } from 'react';
-import { getAddress, zeroAddress } from 'viem';
+import { getAddress, getContract, zeroAddress } from 'viem';
+import { usePublicClient } from 'wagmi';
 import { DAOQueryDocument } from '../../../../.graphclient';
+import AzoriusAbi from '../../../assets/abi/Azorius';
 import { logError } from '../../../helpers/errorLogging';
 import { useFractalModules } from '../../../hooks/DAO/loaders/useFractalModules';
 import { useAsyncRetry } from '../../../hooks/utils/useAsyncRetry';
@@ -23,6 +25,7 @@ export function useFetchNodes(address?: string) {
   const { requestWithRetries } = useAsyncRetry();
 
   const { subgraph } = useNetworkConfig();
+  const publicClient = usePublicClient();
   const { data, error } = useQuery(DAOQueryDocument, {
     variables: { daoAddress: address },
     skip: address === safe?.address || !address, // If address === safe.address - we already have hierarchy obtained in the context
@@ -38,11 +41,8 @@ export function useFetchNodes(address?: string) {
   const getDAOOwner = useCallback(
     async (safeInfo?: Partial<SafeInfoResponseWithGuard>) => {
       if (safeInfo && safeInfo.guard && baseContracts) {
-        const {
-          multisigFreezeGuardMasterCopyContract,
-          azoriusFreezeGuardMasterCopyContract,
-          fractalAzoriusMasterCopyContract,
-        } = baseContracts;
+        const { multisigFreezeGuardMasterCopyContract, azoriusFreezeGuardMasterCopyContract } =
+          baseContracts;
         if (safeInfo.guard !== zeroAddress) {
           const guard = multisigFreezeGuardMasterCopyContract.asProvider.attach(safeInfo.guard);
           const guardOwner = await guard.owner();
@@ -53,15 +53,13 @@ export function useFetchNodes(address?: string) {
           const modules = await lookupModules(safeInfo.modules || []);
           if (!modules) return;
           const azoriusModule = getAzoriusModuleFromModules(modules);
-          if (
-            azoriusModule &&
-            azoriusFreezeGuardMasterCopyContract &&
-            fractalAzoriusMasterCopyContract
-          ) {
-            const azoriusContract = fractalAzoriusMasterCopyContract?.asProvider.attach(
-              azoriusModule.moduleAddress,
-            );
-            const azoriusGuardAddress = await azoriusContract.getGuard();
+          if (azoriusModule && azoriusFreezeGuardMasterCopyContract && publicClient) {
+            const azoriusContract = getContract({
+              abi: AzoriusAbi,
+              address: getAddress(azoriusModule.moduleAddress),
+              client: publicClient,
+            });
+            const azoriusGuardAddress = await azoriusContract.read.getGuard();
             if (azoriusGuardAddress !== zeroAddress) {
               const guard =
                 azoriusFreezeGuardMasterCopyContract.asProvider.attach(azoriusGuardAddress);
@@ -75,7 +73,7 @@ export function useFetchNodes(address?: string) {
       }
       return undefined;
     },
-    [baseContracts, lookupModules],
+    [baseContracts, lookupModules, publicClient],
   );
 
   const fetchDAOInfo = useCallback(

src/components/ui/cards/DAOInfoCard.tsx

@@ -86,7 +86,6 @@ export function DAOInfoCard() {
           {!!user.address && (
             <ManageDAOMenu
               parentAddress={parentAddress}
-              fractalNode={node}
               freezeGuard={guard}
               guardContracts={guardContracts}
             />

src/components/ui/menus/ManageDAO/ManageDAOMenu.tsx

@@ -3,8 +3,7 @@ import { ERC20FreezeVoting, MultisigFreezeVoting } from '@fractal-framework/frac
 import { GearFine } from '@phosphor-icons/react';
 import { useMemo, useCallback, useState, useEffect } from 'react';
 import { useNavigate } from 'react-router-dom';
-import { Address, getAddress } from 'viem';
-import { SENTINEL_ADDRESS } from '../../../../constants/common';
+import { Address } from 'viem';
 import { DAO_ROUTES } from '../../../../constants/routes';
 import {
   isWithinFreezePeriod,
@@ -16,23 +15,21 @@ import useSafeContracts from '../../../../hooks/safe/useSafeContracts';
 import useBlockTimestamp from '../../../../hooks/utils/useBlockTimestamp';
 import { useCanUserCreateProposal } from '../../../../hooks/utils/useCanUserSubmitProposal';
 import { useMasterCopy } from '../../../../hooks/utils/useMasterCopy';
+import useVotingStrategyAddress from '../../../../hooks/utils/useVotingStrategyAddress';
 import { useFractal } from '../../../../providers/App/AppProvider';
 import { useNetworkConfig } from '../../../../providers/NetworkConfig/NetworkConfigProvider';
 import {
   FractalGuardContracts,
-  FractalNode,
   FreezeGuard,
   GovernanceType,
   FreezeVotingType,
 } from '../../../../types';
-import { getAzoriusModuleFromModules } from '../../../../utils';
 import { ModalType } from '../../modals/ModalProvider';
 import { useFractalModal } from '../../modals/useFractalModal';
 import { OptionMenu } from '../OptionMenu';
 
 interface IManageDAOMenu {
   parentAddress: Address | null;
-  fractalNode: FractalNode;
   freezeGuard: FreezeGuard;
   guardContracts: FractalGuardContracts;
 }
@@ -46,57 +43,37 @@ interface IManageDAOMenu {
  *
  * All info for this menu should be supplied in the constructor.
  */
-export function ManageDAOMenu({
-  parentAddress,
-  freezeGuard,
-  guardContracts,
-  fractalNode,
-}: IManageDAOMenu) {
+export function ManageDAOMenu({ parentAddress, freezeGuard, guardContracts }: IManageDAOMenu) {
   const [governanceType, setGovernanceType] = useState(GovernanceType.MULTISIG);
   const {
-    node: { safe },
+    node,
     governance: { type },
   } = useFractal();
   const baseContracts = useSafeContracts();
   const currentTime = BigInt(useBlockTimestamp());
   const navigate = useNavigate();
-  const safeAddress = fractalNode.daoAddress;
+  const safeAddress = node.daoAddress;
   const { getZodiacModuleProxyMasterCopyData } = useMasterCopy();
   const { canUserCreateProposal } = useCanUserCreateProposal();
   const { getUserERC721VotingTokens } = useUserERC721VotingTokens(safeAddress, undefined, false);
   const { handleClawBack } = useClawBack({
     parentAddress,
-    childSafeInfo: fractalNode,
+    childSafeInfo: node,
   });
+  const { getVotingStrategyAddress } = useVotingStrategyAddress();
 
   useEffect(() => {
     const loadGovernanceType = async () => {
-      if (safe && safe.address && safe.address === safeAddress && type) {
+      if (node.safe && node.safe.address && node.safe.address === safeAddress && type) {
         // Since safe.address (global scope DAO address) and safeAddress(Node provided to this component via props)
         // are the same - we can simply grab governance type from global scope and avoid double-fetching
         setGovernanceType(type);
       } else {
-        if (baseContracts) {
+        if (node?.fractalModules) {
           let result = GovernanceType.MULTISIG;
-          const azoriusModule = getAzoriusModuleFromModules(fractalNode.fractalModules);
-          const { fractalAzoriusMasterCopyContract } = baseContracts;
-          if (!!azoriusModule) {
-            const azoriusContract = {
-              asProvider: fractalAzoriusMasterCopyContract.asProvider.attach(
-                azoriusModule.moduleAddress,
-              ),
-              asSigner: fractalAzoriusMasterCopyContract.asSigner.attach(
-                azoriusModule.moduleAddress,
-              ),
-            };
-
-            // @dev assumes the first strategy is the voting contract
-            const votingContractAddress = (
-              await azoriusContract.asProvider.getStrategies(SENTINEL_ADDRESS, 0)
-            )[1];
-            const masterCopyData = await getZodiacModuleProxyMasterCopyData(
-              getAddress(votingContractAddress),
-            );
+          const votingContractAddress = await getVotingStrategyAddress();
+          if (votingContractAddress) {
+            const masterCopyData = await getZodiacModuleProxyMasterCopyData(votingContractAddress);
 
             if (masterCopyData.isOzLinearVoting) {
               result = GovernanceType.AZORIUS_ERC20;
@@ -111,7 +88,14 @@ export function ManageDAOMenu({
     };
 
     loadGovernanceType();
-  }, [fractalNode, safe, safeAddress, type, getZodiacModuleProxyMasterCopyData, baseContracts]);
+  }, [
+    getVotingStrategyAddress,
+    getZodiacModuleProxyMasterCopyData,
+    node?.fractalModules,
+    node.safe,
+    safeAddress,
+    type,
+  ]);
   const { addressPrefix } = useNetworkConfig();
 
   const handleNavigateToSettings = useCallback(() => {

src/components/ui/proposal/useProposalCountdown.tsx

@@ -62,7 +62,7 @@ export function useProposalCountdown(proposal: FractalProposal) {
         (async () => {
           try {
             if (dao?.isAzorius) {
-              await updateProposalState(BigInt(proposal.proposalId));
+              await updateProposalState(Number(proposal.proposalId));
             } else {
               await loadDAOProposals();
             }