update app.py fro mode

app.py

@@ -6,28 +6,43 @@ import plotly.express as px
 from datetime import datetime, timedelta
 import json
 from web3 import Web3
+import os
 from app_trans_new import create_transcation_visualizations,create_active_agents_visualizations
 from app_value_locked import fetch_daily_value_locked
-import os
+# Load environment variables from .env file
 
+# RPC URLs
 OPTIMISM_RPC_URL = os.getenv('OPTIMISM_RPC_URL')
-print('OPTIMISM_RPC_URL',OPTIMISM_RPC_URL)
-# Initialize a Web3 instance
-web3 = Web3(Web3.HTTPProvider(OPTIMISM_RPC_URL))
+MODE_RPC_URL = os.getenv('MODE_RPC_URL')
 
-# Check if connection is successful
-if not web3.is_connected():
-    raise Exception("Failed to connect to the Optimism network.")
+# Initialize Web3 instances
+web3_instances = {
+    'optimism': Web3(Web3.HTTPProvider(OPTIMISM_RPC_URL)),
+    'mode': Web3(Web3.HTTPProvider(MODE_RPC_URL))
+}
 
-# Contract address
-contract_address = '0x3d77596beb0f130a4415df3D2D8232B3d3D31e44'
+# Contract addresses for service registries
+contract_addresses = {
+    'optimism': '0x3d77596beb0f130a4415df3D2D8232B3d3D31e44',
+    'mode': '0x3C1fF68f5aa342D296d4DEe4Bb1cACCA912D95fE'
+}
 
 # Load the ABI from the provided JSON file
 with open('./contracts/service_registry_abi.json', 'r') as abi_file:
     contract_abi = json.load(abi_file)
 
-# Now you can create the contract
-service_registry = web3.eth.contract(address=contract_address, abi=contract_abi)
+# Create the contract instances
+service_registries = {
+    chain_name: web3.eth.contract(address=contract_addresses[chain_name], abi=contract_abi)
+    for chain_name, web3 in web3_instances.items()
+}
+
+# Check if connections are successful
+for chain_name, web3_instance in web3_instances.items():
+    if not web3_instance.is_connected():
+        raise Exception(f"Failed to connect to the {chain_name.capitalize()} network.")
+    else:
+        print(f"Successfully connected to the {chain_name.capitalize()} network.")
 
 def get_transfers(integrator: str, wallet: str) -> str:
     url = f"https://li.quest/v1/analytics/transfers?&wallet={wallet}&fromTimestamp=1726165800"
@@ -35,91 +50,48 @@ def get_transfers(integrator: str, wallet: str) -> str:
     response = requests.get(url, headers=headers)
     return response.json()
 
-def load_activity_checker_contract(w3, staking_token_address):
-    """
-    Loads the Staking Token and Activity Checker contracts.
-
-    :param w3: Web3 instance
-    :param staking_token_address: Address of the staking token contract
-    :return: Tuple of (Staking Token contract instance, Activity Checker contract instance)
-    """
-    try:
-        # Load the ABI file for the Staking Token contract
-        with open('./contracts/StakingToken.json', "r", encoding="utf-8") as file:
-            staking_token_data = json.load(file)
-        
-        staking_token_abi = staking_token_data.get("abi", [])
-
-        # Create the Staking Token contract instance
-        staking_token_contract = w3.eth.contract(address=staking_token_address, abi=staking_token_abi)
-        
-        # Get the activity checker contract address from staking_token_contract
-        activity_checker_address = staking_token_contract.functions.activityChecker().call()
-
-        # Load the ABI file for the Activity Checker contract
-        with open('./contracts/StakingActivityChecker.json', "r", encoding="utf-8") as file:
-            activity_checker_data = json.load(file)
-        
-        activity_checker_abi = activity_checker_data.get("abi", [])
-
-        # Create the Activity Checker contract instance
-        activity_checker_contract = w3.eth.contract(address=activity_checker_address, abi=activity_checker_abi)
-        
-        return staking_token_contract, activity_checker_contract
-    
-    except Exception as e:
-        print(f"An error occurred while loading the contracts: {e}")
-        raise
-
-
 def fetch_and_aggregate_transactions():
-    total_services = service_registry.functions.totalSupply().call()
     aggregated_transactions = []
     daily_agent_counts = {}
-    daily_agents_with_transactions = {}
-
-    _staking_token_contract, activity_checker_contract = load_activity_checker_contract(web3, '0x88996bbdE7f982D93214881756840cE2c77C4992')
-
-    for service_id in range(1, total_services + 1):
-        service = service_registry.functions.getService(service_id).call()
-        # Extract the list of agent IDs from the service data
-        agent_ids = service[-1]  # Assuming the last element is the list of agent IDs
-
-        # Check if 40 is in the list of agent IDs
-        if 40 in agent_ids or 25 in agent_ids:
-            agent_address = service_registry.functions.getAgentInstances(service_id).call()[1][0]
-            response_transfers = get_transfers("valory", agent_address)
-            transfers = response_transfers.get("transfers", [])
-            if isinstance(transfers, list):
-                aggregated_transactions.extend(transfers)
-        
-            # Track the daily number of agents
-            creation_event = service_registry.events.CreateService.create_filter(from_block=0, argument_filters={'serviceId': service_id}).get_all_entries()
-            if creation_event:
-                block_number = creation_event[0]['blockNumber']
-                block = web3.eth.get_block(block_number)
-                creation_timestamp = datetime.fromtimestamp(block['timestamp'])
-                date_str = creation_timestamp.strftime('%Y-%m-%d')
-                print("date_str",date_str)
-                if date_str not in daily_agent_counts:
-                    daily_agent_counts[date_str] = set()
-                if date_str not in daily_agents_with_transactions:
-                    daily_agents_with_transactions[date_str] = set()
-
-                service_safe = service[1]
-                print("agent_address",agent_address,"service_safe",service_safe)
-                multisig_nonces = activity_checker_contract.functions.getMultisigNonces(service_safe).call()[0]
-                if multisig_nonces > 0:
-                    daily_agents_with_transactions[date_str].add(agent_address)
-                daily_agent_counts[date_str].add(agent_address)
-    # Convert set to count
+    seen_agents = set()
+
+    for chain_name, service_registry in service_registries.items():
+        web3 = web3_instances[chain_name]
+        total_services = service_registry.functions.totalSupply().call()
+        for service_id in range(1, total_services + 1):
+            service = service_registry.functions.getService(service_id).call()
+            agent_ids = service[-1]
+
+            if 40 in agent_ids or 25 in agent_ids:
+                agent_address = service_registry.functions.getAgentInstances(service_id).call()[1][0]
+                response_transfers = get_transfers("valory", agent_address)
+                transfers = response_transfers.get("transfers", [])
+                
+                if isinstance(transfers, list):
+                    aggregated_transactions.extend(transfers)
+                
+                # Track the daily number of agents
+                current_date = ""
+                creation_event = service_registry.events.CreateService.create_filter(from_block=0, argument_filters={'serviceId': service_id}).get_all_entries()
+                if creation_event:
+                    block_number = creation_event[0]['blockNumber']
+                    block = web3.eth.get_block(block_number)
+                    creation_timestamp = datetime.fromtimestamp(block['timestamp'])
+                    date_str = creation_timestamp.strftime('%Y-%m-%d')
+                    current_date = date_str
+                    
+                    # Ensure each agent is only counted once based on first registered date
+                    if agent_address not in seen_agents:
+                        seen_agents.add(agent_address)
+                        if date_str not in daily_agent_counts:
+                            daily_agent_counts[date_str] = set()
+                        daily_agent_counts[date_str].add(agent_address)                                
     daily_agent_counts = {date: len(agents) for date, agents in daily_agent_counts.items()}
-    daily_agents_with_transactions = {date: len(agents) for date, agents in daily_agents_with_transactions.items()}
-    return aggregated_transactions, daily_agent_counts, daily_agents_with_transactions
+    return aggregated_transactions, daily_agent_counts
 
 # Function to parse the transaction data and prepare it for visualization
 def process_transactions_and_agents(data):
-    transactions, daily_agent_counts, daily_agents_with_transactions = data
+    transactions, daily_agent_counts = data
 
     # Convert the data into a pandas DataFrame for easy manipulation
     rows = []
@@ -154,99 +126,35 @@ def process_transactions_and_agents(data):
         })
     
     df_transactions = pd.DataFrame(rows)
-    breakpoint()
+    df_transactions = df_transactions.drop_duplicates()
     df_agents = pd.DataFrame(list(daily_agent_counts.items()), columns=['date', 'agent_count'])
-    df_agents_with_transactions = pd.DataFrame(list(daily_agents_with_transactions.items()), columns=['date', 'agent_count_with_transactions'])
-
-    # Convert the date column to datetime
     df_agents['date'] = pd.to_datetime(df_agents['date'])
-    df_agents_with_transactions['date'] = pd.to_datetime(df_agents_with_transactions['date'])
-    
-    # Convert to week periods
     df_agents['week'] = df_agents['date'].dt.to_period('W').apply(lambda r: r.start_time)
-    df_agents_with_transactions['week'] = df_agents_with_transactions['date'].dt.to_period('W').apply(lambda r: r.start_time)
     
-    # Group by week
     df_agents_weekly = df_agents[['week', 'agent_count']].groupby('week').sum().reset_index()
-    df_agents_with_transactions_weekly = df_agents_with_transactions[['week', 'agent_count_with_transactions']].groupby('week').sum().reset_index()
 
-    return df_transactions, df_agents_weekly, df_agents_with_transactions_weekly, df_agents_with_transactions
+    return df_transactions, df_agents, df_agents_weekly
 
 # Function to create visualizations based on the metrics
 def create_visualizations():
     transactions_data = fetch_and_aggregate_transactions()
-    df_transactions, df_agents_weekly, df_agents_with_transactions_weekly, df_agents_with_transactions = process_transactions_and_agents(transactions_data)
-    # Map chain IDs to chain names
-
-        # Fetch daily value locked data
-    df_tvl = fetch_daily_value_locked()
-
-    # Calculate total value locked per chain per day
-    df_tvl["total_value_locked_usd"] = df_tvl["amount0_usd"] + df_tvl["amount1_usd"]
-    df_tvl_daily = df_tvl.groupby(["date", "chain_name"])["total_value_locked_usd"].sum().reset_index()
-    df_tvl_daily['date'] = pd.to_datetime(df_tvl_daily['date'])
-
-    # Filter out dates with zero total value locked
-    df_tvl_daily = df_tvl_daily[df_tvl_daily["total_value_locked_usd"] > 0]
-    chain_name_map = {
-        "optimism": "Optimism",
-        "base": "Base",
-        "ethereum": "Ethereum"
-    }
-    df_tvl_daily["chain_name"] = df_tvl_daily["chain_name"].map(chain_name_map)
-    
-    # Plot total value locked
-    fig_tvl = px.bar(
-        df_tvl_daily,
-        x="date",
-        y="total_value_locked_usd",
-        color="chain_name",
-        opacity=0.7,
-        title="Total Volume Invested in Pools in Different Chains Daily",
-        labels={"date": "Date","chain_name": "Transaction Chain", "total_value_locked_usd": "Total Volume Invested (USD)"},
-        barmode='stack',
-        color_discrete_map={
-            "Optimism": "blue",
-            "Base": "purple",
-            "Ethereum": "darkgreen"
-        }
-    )
-    fig_tvl.update_layout(
-        xaxis_title=None,
-        yaxis=dict(tickmode='linear', tick0=0, dtick=1),
-        xaxis=dict(
-            tickmode='array',
-            tickvals=df_tvl_daily['date'],
-            ticktext=df_tvl_daily['date'].dt.strftime('%b %d'),
-            tickangle=-45,
-        ),
-        bargap=0.6,  # Increase gap between bar groups (0-1)
-        bargroupgap=0.1,  # Decrease gap between bars in a group (0-1)
-        height=600, # Specify width to prevent bars from being too wide
-        margin=dict(l=50, r=50, t=50, b=50),  # Add margins
-        showlegend=True,
-        template='plotly_white'
-    )
-    fig_tvl.update_xaxes(tickformat="%b %d") 
-    
+    df_transactions, df_agents, df_agents_weekly = process_transactions_and_agents(transactions_data)
 
     chain_name_map = {
         10: "Optimism",
         8453: "Base",
         1: "Ethereum",
+        34443: "Mode"
     }
+
     df_transactions["sending_chain"] = df_transactions["sending_chain"].map(chain_name_map)
     df_transactions["receiving_chain"] = df_transactions["receiving_chain"].map(chain_name_map)
 
-    # Ensure that chain IDs are strings for consistent grouping
     df_transactions["sending_chain"] = df_transactions["sending_chain"].astype(str)
     df_transactions["receiving_chain"] = df_transactions["receiving_chain"].astype(str)
     df_transactions['date'] = pd.to_datetime(df_transactions['date'])
+    df_transactions["is_swap"] = df_transactions.apply(lambda x: x["sending_chain"] == x["receiving_chain"], axis=1)
 
-    # Identify swap transactions
-    df_transactions["is_swap"] = df_transactions.apply(lambda x: x["sending_token_symbol"] != x["receiving_token_symbol"], axis=1)
-
-    # Total swaps per chain per day
     swaps_per_chain = df_transactions[df_transactions["is_swap"]].groupby(["date", "sending_chain"]).size().reset_index(name="swap_count")
     fig_swaps_chain = px.bar(
         swaps_per_chain,
@@ -260,7 +168,8 @@ def create_visualizations():
         color_discrete_map={
             "Optimism": "blue",
             "Ethereum": "darkgreen",
-            "Base": "purple"
+            "Base": "purple",
+            "Mode": "orange"
         }
     )
     fig_swaps_chain.update_layout(
@@ -269,14 +178,14 @@ def create_visualizations():
         yaxis=dict(tickmode='linear', tick0=0, dtick=1),
         xaxis=dict(
             tickmode='array',
-            tickvals=[d for d in swaps_per_chain['date'] if d.weekday() == 0],  # Show only Mondays
+            tickvals=[d for d in swaps_per_chain['date'] if d.weekday() == 0],
             ticktext=[d.strftime('%m-%d') for d in swaps_per_chain['date'] if d.weekday() == 0],
             tickangle=-45,
         ),
-        bargap=0.6,  # Increase gap between bar groups (0-1)
-        bargroupgap=0.1,  # Decrease gap between bars in a group (0-1)
-        height=600, # Specify width to prevent bars from being too wide
-        margin=dict(l=50, r=50, t=50, b=50),  # Add margins
+        bargap=0.6,
+        bargroupgap=0.1,
+        height=600,
+        margin=dict(l=50, r=50, t=50, b=50),
         showlegend=True,
         legend=dict(
             yanchor="top",
@@ -288,11 +197,8 @@ def create_visualizations():
     )
     fig_swaps_chain.update_xaxes(tickformat="%m-%d")
 
-    # Identify bridge transactions
-    # Identify bridge transactions
     df_transactions["is_bridge"] = df_transactions.apply(lambda x: x["sending_chain"] != x["receiving_chain"], axis=1)
 
-    # Total bridges per chain per day
     bridges_per_chain = df_transactions[df_transactions["is_bridge"]].groupby(["date", "sending_chain"]).size().reset_index(name="bridge_count")
     fig_bridges_chain = px.bar(
         bridges_per_chain,
@@ -306,7 +212,8 @@ def create_visualizations():
         color_discrete_map={
             "Optimism": "blue",
             "Ethereum": "darkgreen",
-            "Base": "purple"
+            "Base": "purple",
+            "Mode": "orange"
         }
     )
     fig_bridges_chain.update_layout(
@@ -315,14 +222,14 @@ def create_visualizations():
         yaxis=dict(tickmode='linear', tick0=0, dtick=1),
         xaxis=dict(
             tickmode='array',
-            tickvals=[d for d in bridges_per_chain['date'] if d.weekday() == 0],  # Show only Mondays
+            tickvals=[d for d in bridges_per_chain['date'] if d.weekday() == 0],
             ticktext=[d.strftime('%m-%d') for d in bridges_per_chain['date'] if d.weekday() == 0],
             tickangle=-45,
         ),
-        bargap=0.6,  # Increase gap between bar groups (0-1)
-        bargroupgap=0.1,  # Decrease gap between bars in a group (0-1)
-        height=600,  # Specify width to prevent bars from being too wide
-        margin=dict(l=50, r=50, t=50, b=50),  # Add margins
+        bargap=0.6,
+        bargroupgap=0.1,
+        height=600,
+        margin=dict(l=50, r=50, t=50, b=50),
         showlegend=True,
         legend=dict(
             yanchor="top",
@@ -333,46 +240,36 @@ def create_visualizations():
         template='plotly_white'
     )
     fig_bridges_chain.update_xaxes(tickformat="%m-%d")
+    df_agents['date'] = pd.to_datetime(df_agents['date'])
 
-    # Nr of agents registered daily and weekly
-    # Convert 'date' column to datetime
-    df_agents_with_transactions['date'] = pd.to_datetime(df_agents_with_transactions['date'])
+    daily_agents_df = df_agents.groupby('date').agg({'agent_count': 'sum'}).reset_index()
+    daily_agents_df.rename(columns={'agent_count': 'daily_agent_count'}, inplace=True)
+    weekly_agents_df = df_agents.groupby('week').agg({'agent_count': 'sum'}).reset_index()
+    weekly_agents_df.rename(columns={'agent_count': 'weekly_agent_count'}, inplace=True)
 
-    # Calculate daily number of agents registered
-    daily_agents_df = df_agents_with_transactions.groupby('date').size().reset_index(name='daily_agent_count')
-    
-    # Check for October 2, 2024 and update the value
-    daily_agents_df.loc[daily_agents_df['date'] == '2024-10-02', 'daily_agent_count'] = 2
-    
-    # Calculate cumulative number of agents registered within the week up to each day
-    df_agents_with_transactions['week_start'] = df_agents_with_transactions['date'].dt.to_period("W").apply(lambda r: r.start_time)
-    cumulative_agents_df = df_agents_with_transactions.groupby(['week_start', 'date']).size().groupby(level=0).cumsum().reset_index(name='weekly_agent_count')
+    merged_df = pd.merge(daily_agents_df, df_agents[['date', 'week']], on='date', how='left')
+    weekly_merged_df = pd.merge(merged_df, weekly_agents_df, on='week', how='left')
     
-    # Check for October 2, 2024 and update the value
-    cumulative_agents_df.loc[cumulative_agents_df['date'] == '2024-10-02', 'weekly_agent_count'] = 2
-
-    # Combine the data to ensure both dataframes align for plotting
-    combined_df = pd.merge(daily_agents_df, cumulative_agents_df, on='date', how='left')
-
-    # Create the bar chart with side-by-side bars
+    adjustment_date = pd.to_datetime('2024-11-15')
+    weekly_merged_df.loc[weekly_merged_df['date'] == adjustment_date, 'daily_agent_count'] -= 1
+    weekly_merged_df.loc[weekly_merged_df['date'] == adjustment_date, 'weekly_agent_count'] -= 1
     fig_agents_registered = go.Figure(data=[
         go.Bar(
             name='Daily nr of Registered Agents',
-            x=combined_df['date'],
-            y=combined_df['daily_agent_count'],
+            x=weekly_merged_df['date'],
+            y=weekly_merged_df['daily_agent_count'],
             opacity=0.7,
             marker_color='blue'
         ),
         go.Bar(
             name='Total Weekly Nr of Registered Agents',
-            x=combined_df['date'],
-            y=combined_df['weekly_agent_count'],
+            x=weekly_merged_df['date'],
+            y=weekly_merged_df['weekly_agent_count'],
             opacity=0.7,
             marker_color='purple'
         )
     ])
 
-    # Update layout to group bars side by side for each day
     fig_agents_registered.update_layout(
         xaxis_title='Date',
         yaxis_title='Number of Agents',
@@ -381,55 +278,18 @@ def create_visualizations():
         yaxis=dict(tickmode='linear', tick0=0, dtick=1),
         xaxis=dict(
             tickmode='array',
-            tickvals=combined_df['date'],
-            ticktext=[d.strftime("%b %d") for d in combined_df['date']],
+            tickvals=weekly_merged_df['date'],
+            ticktext=[d.strftime("%b %d") for d in weekly_merged_df['date']],
             tickangle=-45
         ),
-        bargap=0.6,  # Increase gap between bar groups (0-1)
-        height=600,  # Specify width to prevent bars from being too wide
-        margin=dict(l=50, r=50, t=50, b=50),  # Add margins
+        bargap=0.6,
+        height=600,
+        margin=dict(l=50, r=50, t=50, b=50),
         showlegend=True,
         template='plotly_white'
     )
 
-        # Calculate weekly average daily active agents
-    df_agents_with_transactions['day_of_week'] = df_agents_with_transactions['date'].dt.dayofweek
-    df_agents_with_transactions_weekly_avg = df_agents_with_transactions.groupby(['week', 'day_of_week'])['agent_count_with_transactions'].mean().reset_index()
-    df_agents_with_transactions_weekly_avg = df_agents_with_transactions_weekly_avg.groupby('week')['agent_count_with_transactions'].mean().reset_index()
-    # Number of agents with transactions per week
-    fig_agents_with_transactions_daily = px.bar(
-        df_agents_with_transactions_weekly,
-        x="week",
-        opacity=0.7,
-        y="agent_count_with_transactions",
-        title="Daily Active Agents: Weekly Average Nr of agents with at least 1 transaction daily",
-        labels={"week": "Week of", "agent_count_with_transactions": "Number of Agents with Transactions"},
-        color_discrete_sequence=["darkgreen"]
-    )
-    fig_agents_with_transactions_daily.update_layout(
-        title=dict(
-        x=0.5,y=0.95,xanchor='center',yanchor='top'),  # Adjust vertical position and Center the title
-        yaxis=dict(tickmode='linear', tick0=0, dtick=1),
-        xaxis=dict(
-            tickmode='array',
-            tickvals=df_agents_with_transactions_weekly_avg['week'],
-            ticktext=df_agents_with_transactions_weekly_avg['week'].dt.strftime('%b %d'),
-            tickangle=0
-        ),
-        bargap=0.6,  # Increase gap between bar groups (0-1)
-        bargroupgap=0.1,  # Decrease gap between bars in a group (0-1)
-        height=600,  # Specify width to prevent bars from being too wide
-        margin=dict(l=50, r=50, t=50, b=50),  # Add margins
-        showlegend=True,
-        legend=dict(
-            yanchor="top",
-            y=0.99,
-            xanchor="right",
-            x=0.99
-        )
-    )
-
-    return fig_swaps_chain, fig_bridges_chain, fig_agents_registered, fig_agents_with_transactions_daily,fig_tvl
+    return fig_swaps_chain, fig_bridges_chain, fig_agents_registered
 
 # Gradio interface
 def dashboard():
@@ -439,28 +299,20 @@ def dashboard():
             fig_tx_chain = create_transcation_visualizations()
             gr.Plot(fig_tx_chain)
 
-        fig_swaps_chain, fig_bridges_chain, fig_agents_registered, fig_agents_with_transactions_daily = create_visualizations()    
-        #Fetch and display visualizations
+        fig_swaps_chain, fig_bridges_chain, fig_agents_registered = create_visualizations()    
         with gr.Tab("Swaps Daily"):
             gr.Plot(fig_swaps_chain)
         
         with gr.Tab("Bridges Daily"):
-            #fig_swaps_chain, fig_bridges_chain, fig_agents_daily, fig_agents_with_transactions_daily,fig_tvl = create_visualizations()
             gr.Plot(fig_bridges_chain)
         
         with gr.Tab("Nr of Agents Registered"):
-            #fig_swaps_chain, fig_bridges_chain, fig_agents_daily, fig_agents_with_transactions_daily,fig_tvl = create_visualizations()
             gr.Plot(fig_agents_registered)
-        
+
         with gr.Tab("DAA"):
             fig_agents_with_transactions_daily = create_active_agents_visualizations()
-            #fig_swaps_chain, fig_bridges_chain, fig_agents_daily, fig_agents_with_transactions_daily,fig_tvl = create_visualizations()
-            gr.Plot(fig_agents_with_transactions_daily)
-
-        with gr.Tab("Total Value Locked"):
-            #fig_swaps_chain, fig_bridges_chain, fig_agents_daily, fig_agents_with_transactions_daily, fig_tvl,fig_tvl = create_visualizations()
-            gr.Plot(fig_tvl) 
-
+            gr.Plot(fig_agents_with_transactions_daily)    
+        
     return demo
 
 # Launch the dashboard