dao-scripts 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

dao_analyzer/cache_scripts/common/thegraph.py

@@ -0,0 +1,203 @@
+from typing import Optional, Callable, Any
+from abc import ABC, abstractmethod
+
+from gql.dsl import DSLField
+
+import pandas as pd
+
+from .common import ENDPOINTS, Runner, NetworkCollector, UpdatableCollector, GQLRequester, get_graph_url
+from ..metadata import Block
+from .. import config
+
+Postprocessor = Callable[[pd.DataFrame], pd.DataFrame]
+
+EMPTY_KEY_MSG = """
+Empty The Graph API key. You can obtain one from https://thegraph.com/docs/en/querying/managing-api-keys/
+"""
+
+def add_where(d: dict[str, Any], **kwargs):
+    """
+    Adds the values specified in kwargs to the where inside d
+        Example: `**add_where(kwargs, deleted=False)`
+    """
+    if "where" in d:
+        d["where"] |= kwargs
+    else:
+        d["where"] = kwargs
+    
+    return d
+
+def partial_query(q: Callable[..., DSLField], w: dict[str, Any]) -> Callable[..., DSLField]:
+    def wrapper(**kwargs):
+        return q(**add_where(kwargs, **w))
+    return wrapper
+
+
+class TheGraphCollector(NetworkCollector, UpdatableCollector, ABC):
+    def __init__(
+        self, 
+        name: str,
+        network: str,
+        subgraph_id: str,
+        runner: Runner,
+        index: Optional[str]=None,
+        result_key: Optional[str]=None,
+        pbar_enabled: bool=True
+    ):
+        super().__init__(name, runner, network)
+
+        self._index_col: str = index or  'id'
+        self._result_key: str = result_key or name
+        self._postprocessors: list[Postprocessor] = []
+        self._indexer_block: Optional[Block] = None
+        self._requester = GQLRequester(
+            endpoint=get_graph_url(subgraph_id),
+            pbar_enabled=pbar_enabled,
+        )
+
+    def postprocessor(self, f: Postprocessor):
+        self._postprocessors.append(f)
+        return f
+
+    @property
+    def endpoint(self):
+        return self._endpoint
+
+    @property
+    def schema(self):
+        return self._requester.get_schema()
+
+    @abstractmethod
+    def query(self, **kwargs) -> DSLField:
+        raise NotImplementedError
+
+    @property
+    def df(self) -> pd.DataFrame:
+        if not self.data_path.is_file():
+            return pd.DataFrame()
+
+        df = pd.read_feather(self.data_path)
+        if self.network:
+            df = df[df['network'] == self.network]
+        
+        return df
+
+    def transform_to_df(self, data: list[dict[str, Any]], skip_post: bool=False) -> pd.DataFrame:
+        df = pd.DataFrame.from_dict(pd.json_normalize(data))
+
+        # For compatibility reasons we change from . to snake case
+        def dotsToSnakeCase(str: str) -> str:
+            splitted = str.split('.')
+            return splitted[0] + ''.join(x[0].upper()+x[1:] for x in splitted[1:])
+                        
+        df = df.rename(columns=dotsToSnakeCase)
+        df['network'] = self.network
+
+        if not skip_post:
+            for post in self._postprocessors:
+                self.logger.debug(f"Running postprocessor {post.__name__}")
+                df = post(df)
+                if df is None:
+                    raise ValueError(f"The postprocessor {post.__name__} returned None")
+
+        return df
+
+    def check_deployment_health(self, deployment_id: str) -> bool:
+        _requester = GQLRequester(ENDPOINTS['_theGraph']['index-node'])
+        ds = _requester.get_schema()
+        q = ds.Query.indexingStatuses(subgraphs=[deployment_id]).select(
+            ds.SubgraphIndexingStatus.node,    
+            ds.SubgraphIndexingStatus.entityCount,
+            ds.SubgraphIndexingStatus.health,
+            ds.SubgraphIndexingStatus.subgraph,
+            ds.SubgraphIndexingStatus.synced,
+            ds.SubgraphIndexingStatus.fatalError.select(
+                ds.SubgraphError.message,
+            ),
+            ds.SubgraphIndexingStatus.nonFatalErrors.select(
+                ds.SubgraphError.message,
+            ),
+            ds.SubgraphIndexingStatus.chains.select(
+                ds.ChainIndexingStatus.network,
+            ),
+        )
+
+        r: dict[str, Any] = _requester.request_single(q)[0]
+        
+        no_errors = True
+        assert r['subgraph'] == deployment_id, "Got response for other subgraph"
+        if r['fatalError']:
+            self.logger.error(f'Subgraph {deployment_id} has fatal error: {r["fatalError"]}')
+            no_errors = False
+
+        if r['health'] != 'healthy':
+            self.logger.error(f'Subgraph {deployment_id} is not healthy.')
+            no_errors = False
+
+        _network = r['chains'][0]['network']
+        if _network != self.network:
+            self.logger.error(f'Subgraph {deployment_id} is deployed on incorrect network. Expected {self.network} but got {_network}')
+            no_errors = False
+
+        if r['nonFatalErrors']:
+            self.logger.warning(f'Subgraph {deployment_id} has non fatal errors, check subgraph studio')
+
+        if not r['synced']:
+            self.logger.warning(f'Subgraph {deployment_id} is not synced. Check subgraph studio.')
+
+        return no_errors
+
+    def check_subgraph_health(self) -> bool:
+        ds = self.schema
+        q = ds.Query._meta().select(
+            ds._Meta_.deployment,
+            ds._Meta_.hasIndexingErrors,
+            ds._Meta_.block.select(
+                ds._Block_.hash,
+                ds._Block_.number,
+                ds._Block_.timestamp,
+            ),
+        )
+
+        r = self._requester.request_single(q)
+
+        if r['hasIndexingErrors']:
+            self.logger.error('Subgraph has indexing errors')
+            return False
+        
+        # TODO: Save the block info to use it later in run
+        self._indexer_block = Block(r['block'])
+        
+        return self.check_deployment_health(r['deployment'])
+
+    def verify(self) -> bool:
+        if not config.THE_GRAPH_API_KEY:
+            self.logger.error('Empty The Graph api key')
+            return False
+        
+        # Checking if the queryBuilder doesnt raise any errors
+        self.query()
+
+        return self.check_subgraph_health()
+
+    def query_cb(self, prev_block: Optional[Block] = None):
+        if prev_block:
+            return partial_query(self.query, {'_change_block': {'number_gte': prev_block.number}})
+        else:
+            return self.query
+
+    def run(self, force=False, block: Optional[Block] = None, prev_block: Optional[Block] = None):
+        self.logger.info(f"Running The Graph collector with block: {block}, prev_block: {prev_block}")
+        if block and self._indexer_block:
+            assert self._indexer_block >= block, "Block number is not indexed yet"
+        
+        if block is None:
+            block = Block()
+        if prev_block is None or force:
+            prev_block = Block()
+
+        data = self._requester.n_requests(query=self.query_cb(prev_block), block_hash=block.id)
+
+        # transform to df
+        df: pd.DataFrame = self.transform_to_df(data)
+        self._update_data(df, force)

dao_analyzer/cache_scripts/config.py

@@ -1,28 +1,70 @@
+from typing import Any
+
+import re
+
 from pathlib import Path
-import os
+from argparse import Namespace
+
+from dynaconf import Dynaconf, Validator
+
+_units = {
+    "B": 1, 
+    "KB": 10**3, "MB": 10**6, "GB": 10**9, "TB": 10**12,
+    "KiB": 2**10, "MiB": 2**20, "GiB": 2**30, "TiB": 2**40,
+}
+
+def parse_size(size):
+    if isinstance(size, int):
+        return size
+
+    size = size.upper()
+    if not re.match(r' ', size):
+        size = re.sub(r'([KMGT]?B)', r' \1', size)
+    number, unit = [string.strip() for string in size.split()]
+    return int(float(number)*_units[unit])
+
+# TODO: Add some way of making very Runner capable of definig its config
+# there somehow
+_RUNNER_VALIDATORS: list[Validator] = [
+    Validator('daohaus.skip_names', cast=bool, default=False),
+    
+    Validator('daostack.registered_only', cast=bool, default=True),
+]
 
-from . import __version__
+settings = Dynaconf(
+    envvar_prefix="DAOA",
+    validate_on_update=True,
+    validators=[
+        Validator('SKIP_INVALID_BLOCKS', cast=int, default=250),
+        Validator('DEFAULT_DATAWAREHOUSE', cast=Path, default=Path("datawarehouse")),
+        Validator('LOGGING_BACKUP_COUNT', cast=int, default=3),
+        Validator('LOGGING_MAX_SIZE', cast=parse_size, default="100MB"),
+        Validator('CC_API_KEY', default=""),
+        Validator('THE_GRAPH_API_KEY', default=""),
 
-CACHE_SCRIPTS_VERSION = __version__
+        # Can be overriden by argparser
+        Validator('run_only_updatable', cast=bool, default=False),
+        Validator('DEBUG', cast=bool, default=False),
+        Validator('raise_runner_errors', cast=bool, default=False),
+        Validator('skip_token_balances', cast=bool, default=False),
 
-# https://letsexchange.io/blog/what-is-block-confirmation-on-ethereum-and-how-many-confirmations-are-required/
-# Number of blocks to skip to only consult confirmed blocks
-SKIP_INVALID_BLOCKS = 250
-DEFAULT_DATAWAREHOUSE = Path(os.getenv('DAOA_DW_PATH', 'datawarehouse'))
+        *_RUNNER_VALIDATORS,
+    ]
+)
 
-# LOGGING CONFIG
-LOGGING_BACKUP_COUNT = os.getenv('DAOA_LOGGING_BACKUP_COUNT', 3)
-LOGGING_MAX_MB = os.getenv('DAOA_LOGGING_MAX_MB', 100)
+def _sanitize_argname(name: str) -> str:
+    return name.replace(".", "__")
 
-__args = None
+def args2config(args: Namespace):
+    argsdict: dict[str, Any] = vars(args)
 
-def populate_args(args):
-    global __args
-    __args = args
+    all_names = [ (vn,_sanitize_argname(vn)) for v in settings.validators for vn in v.names ]
+    settings_update = { vn:(argsdict[an] or settings[vn]) for vn, an in all_names if an in argsdict }
 
+    settings.update(settings_update)
 
 def __getattr__(name):
     """
     Called when no function has been defined. Defaults to search argsparser.
     """
-    return __args.__getattribute__(name)
+    return settings[name]

dao_analyzer/cache_scripts/daohaus/runner.py

@@ -19,14 +19,14 @@ from .. import config
 from ..common.common import solve_decimals
 from ..common.cryptocompare import cc_postprocessor
 
-from ..common import ENDPOINTS, Collector
-from ..common.graphql import GraphQLCollector, GraphQLRunner, add_where
+from ..common import ENDPOINTS, Collector, NetworkRunner
+from ..common.thegraph import TheGraphCollector, add_where
 
 DATA_ENDPOINT: str = "https://data.daohaus.club/dao/{id}"
 
-class MembersCollector(GraphQLCollector):
+class MembersCollector(TheGraphCollector):
     def __init__(self, runner, network: str):
-        super().__init__('members', runner, network=network, endpoint=ENDPOINTS[network]['daohaus'])
+        super().__init__('members', network, ENDPOINTS[network]['daohaus'], runner)
 
     def query(self, **kwargs) -> DSLField:
         ds = self.schema
@@ -42,9 +42,9 @@ class MembersCollector(GraphQLCollector):
             ds.Member.didRagequit
         )
 
-class MolochesCollector(GraphQLCollector):
+class MolochesCollector(TheGraphCollector):
     def __init__(self, runner, network: str):
-        super().__init__('moloches', runner, network=network, endpoint=ENDPOINTS[network]['daohaus'])
+        super().__init__('moloches', network, ENDPOINTS[network]['daohaus'], runner)
 
         @self.postprocessor
         def moloch_id(df: pd.DataFrame) -> pd.DataFrame:
@@ -55,7 +55,7 @@ class MolochesCollector(GraphQLCollector):
         def moloch_names(df: pd.DataFrame) -> pd.DataFrame:
             df = df.rename(columns={"title":"name"})
 
-            if config.skip_daohaus_names:
+            if config.daohaus.skip_names:
                 return df
 
             cached = requests_cache.CachedSession(self.runner.cache / 'daohaus_names_cache', 
@@ -92,9 +92,9 @@ class MolochesCollector(GraphQLCollector):
             ds.Moloch.totalLoot,
         )
 
-class ProposalsCollector(GraphQLCollector):
+class ProposalsCollector(TheGraphCollector):
     def __init__(self, runner, network: str):
-        super().__init__('proposals', runner, network=network, endpoint=ENDPOINTS[network]["daohaus"])
+        super().__init__('proposals', network, ENDPOINTS[network]['daohaus'], runner)
 
     def query(self, **kwargs) -> DSLField:
         ds = self.schema
@@ -123,9 +123,9 @@ class ProposalsCollector(GraphQLCollector):
             ds.Proposal.details,
         )
     
-class RageQuitCollector(GraphQLCollector):
+class RageQuitCollector(TheGraphCollector):
     def __init__(self, runner, network: str):
-        super().__init__('rageQuits', runner, network=network, endpoint=ENDPOINTS[network]["daohaus"])
+        super().__init__('rageQuits', network, ENDPOINTS[network]['daohaus'], runner)
 
     def query(self, **kwargs) -> DSLField:
         ds = self.schema
@@ -138,9 +138,9 @@ class RageQuitCollector(GraphQLCollector):
             ds.RageQuit.loot
         )
 
-class TokenBalancesCollector(GraphQLCollector):
+class TokenBalancesCollector(TheGraphCollector):
     def __init__(self, runner, network: str):
-        super().__init__('tokenBalances', runner, network=network, endpoint=ENDPOINTS[network]["daohaus"])
+        super().__init__('tokenBalances', network, ENDPOINTS[network]['daohaus'], runner)
 
         @self.postprocessor
         def change_col_names(df: pd.DataFrame) -> pd.DataFrame:
@@ -163,8 +163,8 @@ class TokenBalancesCollector(GraphQLCollector):
         
             return df
         
-        self.postprocessors.append(solve_decimals)
-        self.postprocessors.append(cc_postprocessor)
+        self.postprocessor(solve_decimals)
+        self.postprocessor(cc_postprocessor)
 
     def query(self, **kwargs) -> DSLField:
         ds = self.schema
@@ -184,9 +184,9 @@ class TokenBalancesCollector(GraphQLCollector):
             ds.TokenBalance.tokenBalance
         )
 
-class VoteCollector(GraphQLCollector):
+class VoteCollector(TheGraphCollector):
     def __init__(self, runner, network: str):
-        super().__init__('votes', runner, network=network, endpoint=ENDPOINTS[network]["daohaus"])
+        super().__init__('votes', network, ENDPOINTS[network]['daohaus'], runner)
 
         @self.postprocessor
         def changeColumnNames(df: pd.DataFrame) -> pd.DataFrame:
@@ -204,11 +204,11 @@ class VoteCollector(GraphQLCollector):
             ds.Vote.uintVote
         )
 
-class DaohausRunner(GraphQLRunner):
+class DaohausRunner(NetworkRunner):
     name: str = 'daohaus'
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, dw):
+        super().__init__(dw)
         self._collectors: List[Collector] = []
         for n in self.networks:
             self._collectors.extend([

dao_analyzer/cache_scripts/daostack/runner.py

@@ -15,8 +15,8 @@ from .. import config
 from ..common.blockscout import BlockscoutBallancesCollector
 from ..common.cryptocompare import CCPricesCollector
 
-from ..common import ENDPOINTS, Collector
-from ..common.graphql import GraphQLCollector, GraphQLRunner, add_where
+from ..common import ENDPOINTS, Collector, NetworkRunner
+from ..common.thegraph import TheGraphCollector, add_where
 
 def _changeProposalColumnNames(df: pd.DataFrame) -> pd.DataFrame:
     df = df.rename(columns={
@@ -38,9 +38,9 @@ class BalancesCollector(BlockscoutBallancesCollector):
     def __init__(self, runner, base, network: str):
         super().__init__(runner, base=base, network=network, addr_key='dao')
 
-class DaosCollector(GraphQLCollector):
+class DaosCollector(TheGraphCollector):
     def __init__(self, runner, network: str):
-        super().__init__('daos', runner, network=network, endpoint=ENDPOINTS[network]['daostack'])
+        super().__init__('daos', network, ENDPOINTS[network]['daostack'], runner)
         
         @self.postprocessor
         def changeColumnNames(df: pd.DataFrame) -> pd.DataFrame:
@@ -60,9 +60,9 @@ class DaosCollector(GraphQLCollector):
     def query(self, **kwargs) -> DSLField:
         ds = self.schema
 
-        where = { 'register': 'registered' }
-        if config.daostack_all:
-            where.pop('register')
+        where = dict()
+        if config.daostack.registered_only:
+            where['register'] = 'registered'
         
         return ds.Query.daos(**add_where(kwargs, **where)).select(
             ds.DAO.id,
@@ -72,9 +72,9 @@ class DaosCollector(GraphQLCollector):
             ds.DAO.nativeReputation.select(ds.Rep.id)
         )
 
-class ProposalsCollector(GraphQLCollector):
+class ProposalsCollector(TheGraphCollector):
     def __init__(self, runner, network: str, daoC: DaosCollector):
-        super().__init__('proposals', runner, network=network, endpoint=ENDPOINTS[network]['daostack'])
+        super().__init__('proposals', network, ENDPOINTS[network]['daostack'], runner)
 
         @self.postprocessor
         def changeColumnNames(df: pd.DataFrame) -> pd.DataFrame:
@@ -86,7 +86,7 @@ class ProposalsCollector(GraphQLCollector):
         def deleteColums(df: pd.DataFrame) -> pd.DataFrame:
             return df.drop(columns=['competition'], errors='ignore')
 
-        self.postprocessors.append(_remove_phantom_daos_wr(daoC))
+        self.postprocessor(_remove_phantom_daos_wr(daoC))
 
     @staticmethod
     def _stripGenesis(s: str):
@@ -139,12 +139,11 @@ class ProposalsCollector(GraphQLCollector):
             ds.Proposal.competition.select(ds.CompetitionProposal.id)
         )
 
-class ReputationHoldersCollector(GraphQLCollector):
+class ReputationHoldersCollector(TheGraphCollector):
     def __init__(self, runner, network: str, daoC: DaosCollector):
-        super().__init__('reputationHolders', runner, network=network, endpoint=ENDPOINTS[network]['daostack'])
+        super().__init__('reputationHolders', network, ENDPOINTS[network]['daostack'], runner)
         self.postprocessor(_changeProposalColumnNames)
-
-        self.postprocessors.append(_remove_phantom_daos_wr(daoC))
+        self.postprocessor(_remove_phantom_daos_wr(daoC))
 
     def query(self, **kwargs) -> DSLField:
         ds = self.schema
@@ -157,12 +156,11 @@ class ReputationHoldersCollector(GraphQLCollector):
             ds.ReputationHolder.dao.select(ds.DAO.id)
         )
 
-class StakesCollector(GraphQLCollector):
+class StakesCollector(TheGraphCollector):
     def __init__(self, runner, network: str, daoC: DaosCollector):
-        super().__init__('stakes', runner, network=network, endpoint=ENDPOINTS[network]['daostack'])
+        super().__init__('stakes',network, ENDPOINTS[network]['daostack'], runner)
         self.postprocessor(_changeProposalColumnNames)
-    
-        self.postprocessors.append(_remove_phantom_daos_wr(daoC))
+        self.postprocessor(_remove_phantom_daos_wr(daoC))
 
     def query(self, **kwargs) -> DSLField:
         ds = self.schema
@@ -179,12 +177,11 @@ class StakesCollector(GraphQLCollector):
 class TokenPricesCollector(CCPricesCollector):
     pass
 
-class VotesCollector(GraphQLCollector):
+class VotesCollector(TheGraphCollector):
     def __init__(self, runner, network: str, daoC: DaosCollector):
-        super().__init__('votes', runner, network=network, endpoint=ENDPOINTS[network]['daostack'])
+        super().__init__('votes', network, ENDPOINTS[network]['daostack'], runner)
         self.postprocessor(_changeProposalColumnNames)
-
-        self.postprocessors.append(_remove_phantom_daos_wr(daoC))
+        self.postprocessor(_remove_phantom_daos_wr(daoC))
 
     def query(self, **kwargs) -> DSLField:
         ds = self.schema
@@ -198,9 +195,9 @@ class VotesCollector(GraphQLCollector):
             ds.ProposalVote.proposal.select(ds.Proposal.id)
         )
 
-class CommonRepEventCollector(GraphQLCollector):
+class CommonRepEventCollector(TheGraphCollector):
     def __init__(self, name, runner, base, network: str): 
-        super().__init__(name, runner, network=network, endpoint=ENDPOINTS[network]['daostack'])
+        super().__init__(name, network, ENDPOINTS[network]['daostack'], runner)
         self.base = base
 
         @self.postprocessor
@@ -230,7 +227,7 @@ class CommonRepEventCollector(GraphQLCollector):
             
             return df
 
-        self.postprocessors.append(_remove_phantom_daos_wr(self.base))
+        self.postprocessor(_remove_phantom_daos_wr(self.base))
 
 class ReputationMintsCollector(CommonRepEventCollector):
     def __init__(self, *args, **kwargs):
@@ -262,11 +259,11 @@ class ReputationBurnsCollector(CommonRepEventCollector):
             ds.ReputationBurn.createdAt
         )
 
-class DaostackRunner(GraphQLRunner):
+class DaostackRunner(NetworkRunner):
     name: str = 'daostack'
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, dw):
+        super().__init__(dw)
         self._collectors: List[Collector] = []
         for n in self.networks:
             dc = DaosCollector(self, n)

dao_analyzer/cache_scripts/endpoints.json

@@ -1,31 +1,27 @@
 {
     "mainnet": {
-        "_blocks": "https://api.thegraph.com/subgraphs/name/blocklytics/ethereum-blocks",
+        "_blocks": "9A6bkprqEG2XsZUYJ5B2XXp6ymz9fNcn4tVPxMWDztYC",
         "blockscout": "https://blockscout.com/eth/mainnet/api",
-        "daostack": "https://api.thegraph.com/subgraphs/name/grasia/daostack",
-        "daohaus": "https://api.thegraph.com/subgraphs/name/odyssy-automaton/daohaus",
-        "aragon": "https://api.thegraph.com/subgraphs/name/aragon/aragon-mainnet",
-        "aragon_tokens": "https://api.thegraph.com/subgraphs/name/grasia/aragon-tokens-mainnet",
-        "aragon_voting": "https://api.thegraph.com/subgraphs/name/grasia/aragon-voting-mainnet",
-        "aragon_finance": "https://api.thegraph.com/subgraphs/name/grasia/aragon-finance-mainnet"
+        "daostack": "43HtV3dXRLPX7GKyV7f8GMLhevPXBmnSvpGBRKyfr53k",
+        "daohaus": "2d3CDkKyxhpLDZRLWHMCvWp9cCYdWp4Y7g5ecaBmeqad",
+        "aragon": "QmduJYwyy3STKaZCEEHtxCQ9LMRYDPdfqYbgobRob6bDp7",
+        "aragon_tokens": "EioF9792T18u3oqtt2Hfv5gYgw2Rp2qeqnrURP6deVHg",
+        "aragon_voting": "GBsV7wbrW9gTBjJhvBpML5Gcadtaj1fEnapB6NujNaai",
+        "aragon_finance": "7pHfNgz8XYHH2Uu9RdqqP8G29BCqi1VRgo3cdLzz59HZ"
     },
     "xdai": {
-        "_blocks": "https://api.thegraph.com/subgraphs/name/1hive/xdai-blocks",
+        "_blocks": "D58aXwnRLfosFtRaVJAbAjjvKZ11bEsbdiDLkJJRdSC9",
         "blockscout": "https://blockscout.com/xdai/mainnet/api",
-        "daostack": "https://api.thegraph.com/subgraphs/name/grasia/daostack-xdai",
-        "daohaus": "https://api.thegraph.com/subgraphs/name/odyssy-automaton/daohaus-xdai",
-        "aragon": "https://api.thegraph.com/subgraphs/name/1hive/aragon-xdai",
-        "aragon_tokens": "https://api.thegraph.com/subgraphs/name/grasia/aragon-tokens-xdai",
-        "aragon_voting": "https://api.thegraph.com/subgraphs/name/grasia/aragon-voting-xdai",
-        "aragon_finance": "https://api.thegraph.com/subgraphs/name/grasia/aragon-finance-xdai"
+        "daostack": "Bnqq6ARphxg2rnAvjBrQGxCPNtDGiygv235GbRzZqwfb",
+        "daohaus": "2GJY9uxsLQUCvgqSfy6QCLAJgM9P9kdxBUpwNcGs7nPR"
     },
     "polygon": {
-        "_blocks": "https://api.thegraph.com/subgraphs/name/grasia/matic-blocks",
-        "daohaus": "https://api.thegraph.com/subgraphs/name/odyssy-automaton/daohaus-matic"
+        "_blocks": "4mJTujCUWKLd4SPBYE1YXbamfNSNRMyphk8tHzczYWf9",
+        "daohaus": "AkzZk4BsvfNRkRDtzz7Bc8TgktTJN4uv9tgfCehhE6fB"
     },
     "arbitrum": {
-        "_blocks": "https://api.thegraph.com/subgraphs/name/grasia/arbitrum-blocks",
-        "daohaus": "https://api.thegraph.com/subgraphs/name/odyssy-automaton/daohaus-arbitrum"
+        "_blocks": "AyY1GDtmAyavGWsdoHQ4vNoBCVWSqfDwHa6jPu5KdHgP",
+        "daohaus": "2c41cggebRCMzFiDqoqDwShZtz4xYucsFKbQnEiXUTzY"
     },
     "_theGraph": {
         "index-node": "https://api.thegraph.com/index-node/graphql"