update daily tnxs and DAA for mode

app_trans_new.py

@@ -14,17 +14,22 @@ from itertools import product
 OPTIMISM_RPC_URL = os.getenv('OPTIMISM_RPC_URL')
 BASE_RPC_URL = os.getenv('BASE_RPC_URL')
 ETH_RPC_URL = os.getenv('ETH_RPC_URL')
+MODE_RPC_URL = os.getenv('MODE_RPC_URL')
+
+
 
 # Initialize Web3 instances
 print("Initializing Web3 instances...")
 web3_optimism = Web3(Web3.HTTPProvider(OPTIMISM_RPC_URL))
 web3_base = Web3(Web3.HTTPProvider(BASE_RPC_URL))
 web3_eth = Web3(Web3.HTTPProvider(ETH_RPC_URL))
+web3_mode = Web3(Web3.HTTPProvider(MODE_RPC_URL))  # New chain
 
 # Contract addresses for service registries
 contract_address_optimism = '0x3d77596beb0f130a4415df3D2D8232B3d3D31e44'
 contract_address_base = '0x3C1fF68f5aa342D296d4DEe4Bb1cACCA912D95fE'
 contract_address_eth = '0x48b6af7B12C71f09e2fC8aF4855De4Ff54e775cA'
+contract_address_mode = '0x3C1fF68f5aa342D296d4DEe4Bb1cACCA912D95fE'  # New chain
 
 # Load the ABI from a local JSON file
 with open('./contracts/service_registry_abi.json', 'r') as abi_file:
@@ -34,6 +39,7 @@ with open('./contracts/service_registry_abi.json', 'r') as abi_file:
 service_registry_optimism = web3_optimism.eth.contract(address=contract_address_optimism, abi=contract_abi)
 service_registry_base = web3_base.eth.contract(address=contract_address_base, abi=contract_abi)
 service_registry_eth = web3_eth.eth.contract(address=contract_address_eth, abi=contract_abi)
+service_registry_mode = web3_mode.eth.contract(address=contract_address_mode, abi=contract_abi)  # New chain
 print("Service registry contracts loaded.")
 
 # Check if connection is successful
@@ -43,37 +49,50 @@ if not web3_base.is_connected():
     raise Exception("Failed to connect to the Base network.")
 if not web3_eth.is_connected():
     raise Exception("Failed to connect to the ETH network.")
-print("Successfully connected to Ethereum, Optimism, and Base networks.")
+if not web3_mode.is_connected():
+    raise Exception("Failed to connect to the Mode network.")  # New chain
+print("Successfully connected to Ethereum, Optimism, Base, and Mode networks.")
+
 
 
 def fetch_service_safes(web3, registry_contract):
     print("\nFetching service safes...")
     total_services = registry_contract.functions.totalSupply().call()
     print(f"Total services: {total_services}")
-    service_safes = set()
-
+    service_safes_dict = {}
+    zero_address = '0x0000000000000000000000000000000000000000'
+    
     for service_id in range(1, total_services + 1):
         print(f"Processing service ID: {service_id}")
         service = registry_contract.functions.getService(service_id).call()
         agent_ids = service[-1]  # Assuming the last element is the list of agent IDs
         print(f"Agent IDs: {agent_ids}")
 
-        if 40 in agent_ids:
-            agent_address = registry_contract.functions.getAgentInstances(service_id).call()
+        if 40 in agent_ids or 25 in agent_ids:
+            agent_instance_data = registry_contract.functions.getAgentInstances(service_id).call()
             service_safe = service[1]
-            print(f"Found agent_address: {agent_address}")
-            print(f"Found service safe: {service_safe}")
-            service_safes.add(service_safe)
+            agent_addresses = agent_instance_data[1]
+            if agent_addresses:
+                agent_address = agent_addresses[0]
+                if service_safe != zero_address:
+                    print(f"Found agent_address: {agent_address}")
+                    print(f"Found service safe: {service_safe}")
+                    service_safes_dict[agent_address] = service_safe
+                else:
+                    print(f"Found zero address for service safe, skipping for agent: {agent_address}")
+            else:
+                print(f"No agent address found for service ID: {service_id}")
 
-    print(f"Total service safes found: {len(service_safes)}")
-    return service_safes
+    print(f"Total unique agent addresses found (excluding zero safe addresses): {len(service_safes_dict)}")
+    return service_safes_dict
 
 # Fetch service safes for each network
 service_safes_optimism = fetch_service_safes(web3_optimism, service_registry_optimism)
 service_safes_base = fetch_service_safes(web3_base, service_registry_base)
 service_safes_eth = fetch_service_safes(web3_eth, service_registry_eth)
-service_safes_eth = {safe for safe in service_safes_eth if safe.lower() != '0x0000000000000000000000000000000000000000'}
-
+service_safes_mode = fetch_service_safes(web3_mode, service_registry_mode)
+# service_safes_eth = {safe for safe in service_safes_eth if safe.lower() != '0x0000000000000000000000000000000000000000'}
+print(f"Service safes for Mode: {service_safes_mode}")
 def get_block_range_for_date(chain_id, date_str, api_key, base_url):
     """Get the block range for a specific date."""
     target_date = datetime.strptime(date_str, "%Y-%m-%d").date()
@@ -122,12 +141,22 @@ def get_block_range_for_date(chain_id, date_str, api_key, base_url):
 
     return start_block, end_block
 
+def get_transactions_mode_all(address):
+    url = f'https://explorer.mode.network/api/v2/addresses/{address}/transactions'
+    headers = {
+        'accept': 'application/json'
+    }
+    
+    response = requests.get(url, headers=headers)
+    return response.json()['items']
+
 def get_transactions(api_keys, wallet_address, chain_name, start_block, end_block):
     """Retrieve transactions for the given wallet address, chain, and block range using the Etherscan or similar API."""
     base_url = {
         'optimism': "https://api-optimistic.etherscan.io/api",
         'base': "https://api.basescan.org/api",
-        'ethereum': "https://api.etherscan.io/api"
+        'ethereum': "https://api.etherscan.io/api",
+        'mode': "https://eth-sepolia.blockscout.com/api"
     }.get(chain_name)
 
     if not base_url:
@@ -157,6 +186,34 @@ def get_transactions(api_keys, wallet_address, chain_name, start_block, end_bloc
     
     return valid_transactions
 
+def get_mode_transactions(transactions_all_base,date_str):
+    target_date = datetime.strptime(date_str, "%Y-%m-%d").date()
+    start_of_day = datetime.combine(target_date, datetime.min.time())
+    
+    if target_date == datetime.now().date():
+        end_of_day = datetime.now()  # Use the current time if the target date is today
+    else:
+        end_of_day = datetime.combine(target_date, datetime.max.time())
+
+    start_timestamp = start_of_day.isoformat()
+    end_timestamp = end_of_day.isoformat()
+    processed_list = []
+    for transaction in transactions_all_base:
+        # Filter transactions based on the timestamp
+        if start_timestamp <= transaction['timestamp'] <= end_timestamp:
+            transaction_timestamp = datetime.strptime(transaction['timestamp'], "%Y-%m-%dT%H:%M:%S.%fZ").strftime("%Y-%m-%d %H:%M:%S")
+            processed_transaction = {
+                'hash': transaction['hash'],
+                'timeStamp': transaction_timestamp,
+                'from': transaction['from']['hash'],
+                'to': transaction['to']['hash'],
+                'value': transaction['value']
+            }
+            processed_list.append(processed_transaction)
+
+    return processed_list       
+
+
 def date_range(start_date, end_date):
     """Generates a range of dates from start_date to end_date inclusive."""
     start_dt = datetime.strptime(start_date, "%Y-%m-%d")
@@ -171,13 +228,15 @@ def fetch_transactions():
     api_keys = {
         'optimism': 'XQ72JA5XZ51QC7TG1W295AAIF4KTV92K1K',
         'base': '4BFQMVW1QUKEPVDA4VW711CF4462682CY8',
-        'ethereum': '3GRYJGX55W3QWCEKGREF4H53AFHCAIVVR7'
+        'ethereum': '3GRYJGX55W3QWCEKGREF4H53AFHCAIVVR7',
+        'mode': 'f651444d-2916-4f37-bfd8-e70cc8232eb7'
     }
 
     base_urls = {
         10: "https://api-optimistic.etherscan.io/api",
         8453: "https://api.basescan.org/api",
-        1: "https://api.etherscan.io/api"
+        1: "https://api.etherscan.io/api",
+        3443: "https://eth-sepolia.blockscout.com/api"
     }
 
     current_date = datetime.today().strftime("%Y-%m-%d")
@@ -199,7 +258,8 @@ def fetch_transactions():
     chains = {
         10: ('optimism', service_safes_optimism),
         8453: ('base', service_safes_base),
-        1: ('ethereum', service_safes_eth)
+        1: ('ethereum', service_safes_eth),
+        3443: ('mode', service_safes_mode)
     }
 
     all_transactions = df_existing.to_dict('records') if not df_existing.empty else []
@@ -208,36 +268,60 @@ def fetch_transactions():
         base_url = base_urls[chain_id]
         api_key = api_keys[chain_name]
 
-        for safe_address in service_safes:
-            print(f"\nProcessing {chain_name.capitalize()} for safe address {safe_address}...")
+        for agent_address, safe_address in service_safes.items():
+            print(f"\nProcessing {chain_name.capitalize()} for agent address {agent_address} (safe address {safe_address})...")
+            if chain_name == 'mode':
+                transactions_all_base = get_transactions_mode_all(safe_address)
+            
             for single_date in date_range(start_date, current_date):
-                start_block, end_block = get_block_range_for_date(chain_id, single_date, api_key, base_url)
-                if start_block is None or end_block is None:
-                    print(f"Skipping date {single_date} for chain {chain_name} due to missing block data.")
-                    continue
-
-                print(f"Start Block: {start_block}, End Block: {end_block} for date {single_date}")
-
-                transactions = get_transactions(api_keys, safe_address, chain_name, start_block, end_block)
-
+                if chain_name == 'mode':
+                    print(f"Processing date {single_date} for chain {chain_name}...")
+                    transactions = get_mode_transactions(transactions_all_base,single_date)
+                    
+                else:
+                    print(f"Processing date {single_date} for chain {chain_name}...")
+                    start_block, end_block = get_block_range_for_date(chain_id, single_date, api_key, base_url)
+                    if start_block is None or end_block is None:
+                        print(f"Skipping date {single_date} for chain {chain_name} due to missing block data.")
+                        continue
+                    print(f"Start Block: {start_block}, End Block: {end_block} for date {single_date}")
+                    transactions = get_transactions(api_keys, safe_address, chain_name, start_block, end_block)
+                    
                 if transactions:
                     print(f"Found {len(transactions)} transactions on {single_date} for {chain_name.capitalize()} safe address {safe_address}:")
                     for tx in transactions:
-                        tx_time = datetime.fromtimestamp(int(tx['timeStamp']))
-                        all_transactions.append({
-                            'chain': chain_name,
-                            'safe_address': safe_address,
-                            'date': single_date,
-                            'transaction_hash': tx['hash'],
-                            'timestamp': tx_time,
-                            'from': tx['from'],
-                            'to': tx['to'],
-                            'value_eth': int(tx['value']) / 1e18  # Convert value to ETH
-                        })
+                        if chain_name != 'mode':
+                            print(f"Transaction Hash: {tx['hash']} on {chain_name.capitalize()} at {tx['timeStamp']}")
+                            tx_time = datetime.fromtimestamp(int(tx['timeStamp']))
+                            all_transactions.append({
+                                'chain': chain_name,
+                                'agent_address': agent_address,
+                                'safe_address': safe_address,
+                                'date': single_date,
+                                'transaction_hash': tx['hash'],
+                                'timestamp': tx_time,
+                                'from': tx['from'],
+                                'to': tx['to'],
+                                'value_eth': int(tx['value']) / 1e18  # Convert value to ETH
+                            })
+                        else:
+                            all_transactions.append({
+                                'chain': chain_name,
+                                'agent_address': agent_address,
+                                'safe_address': safe_address,
+                                'date': single_date,
+                                'transaction_hash': tx['hash'],
+                                'timestamp': tx['timeStamp'],
+                                'from': tx['from'],
+                                'to': tx['to'],
+                                'value_eth': int(tx['value']) / 1e18  # Convert value to ETH
+                            })
+
                 else:
-                    print(f"No transactions found for safe address {safe_address} on {single_date} on {chain_name.capitalize()}.")
+                    print(f"No transactions found for agent address {agent_address} (safe address {safe_address}) on {single_date} on {chain_name.capitalize()}.")
 
     df_transactions_new = pd.DataFrame(all_transactions)
+    df_transactions_new = df_transactions_new[df_transactions_new['date'] != '2024-11-20']
     df_transactions_new.to_csv(csv_filename, index=False)
     return df_transactions_new
 
@@ -250,7 +334,7 @@ def create_transcation_visualizations():
     daily_counts = df_transactions_new.groupby([df_transactions_new['timestamp'].dt.date, 'chain']).size().unstack(fill_value=0)
 
         # Ensure required chains are present
-    chains = ['optimism', 'base', 'ethereum']
+    chains = ['optimism', 'base', 'ethereum', 'mode'] 
     for chain in chains:
         if chain not in daily_counts.columns:
             daily_counts[chain] = 0
@@ -288,7 +372,7 @@ def create_transcation_visualizations():
         new_rows.extend([slot1])
         slot2 = row.copy()
         if slot2['timestamp'].dayofweek == 6:  # 6 represents Sunday
-            slot2[['optimism', 'base', 'ethereum']] = 0
+            slot2[chains] = 0
             slot2['timestamp'] = row['timestamp'].replace(hour=12)
             new_rows.extend([slot2])
         
@@ -299,7 +383,7 @@ def create_transcation_visualizations():
 
     # Prepare data for plotting
     dates = hourly_counts['timestamp'].tolist()
-    values = hourly_counts[['optimism', 'base', 'ethereum']].to_numpy()
+    values = hourly_counts[chains].to_numpy()
 
     # Create the figure
     fig = go.Figure()
@@ -354,6 +438,17 @@ def create_transcation_visualizations():
         textposition='none',
     ))
 
+    fig.add_trace(go.Bar(
+        name='Mode',
+        x=x_numeric,
+        y=values[:,3],
+        marker_color='orange',
+        opacity=0.7,
+        text=None,
+        width=width_array,
+        textposition='none',
+    ))
+
     # Update layout with numeric x-axis
     fig.update_layout(
         title='Chain Daily Activity : Transactions',
@@ -397,7 +492,7 @@ def create_active_agents_visualizations():
     df_transactions_new['weekday'] = df_transactions_new['timestamp'].dt.weekday
     
     # Count unique agents per day
-    daily_agents = df_transactions_new.groupby(['week_start', 'weekday'])['from'].nunique().reset_index()
+    daily_agents = df_transactions_new.groupby(['week_start', 'weekday'])['agent_address'].nunique().reset_index()
     
     # Generate all possible combinations of week_start and weekday up to today
     today = datetime.today()
@@ -410,8 +505,8 @@ def create_active_agents_visualizations():
     daily_agents = all_combinations.merge(daily_agents, on=['week_start', 'weekday'], how='left').fillna(0)
     
     # Compute average unique agents per week
-    weekly_avg_agents = daily_agents.groupby('week_start')['from'].mean().reset_index()
-    weekly_avg_agents.rename(columns={'from': 'avg_daily_active_agents'}, inplace=True)
+    weekly_avg_agents = daily_agents.groupby('week_start')['agent_address'].mean().reset_index()
+    weekly_avg_agents.rename(columns={'agent_address': 'avg_daily_active_agents'}, inplace=True)
     
     # Prepare data for plotting
     weeks = weekly_avg_agents['week_start'].unique()