revertring changes

app.py

@@ -2,156 +2,109 @@ import requests
 import pandas as pd
 import gradio as gr
 import plotly.express as px
-from datetime import datetime, timedelta
-from web3 import Web3
-from web3.middleware.geth_poa import geth_poa_middleware
-
-# Optimism RPC endpoint (you can use Infura, Alchemy, or any other provider)
-OPTIMISM_RPC = "https://mainnet.optimism.io"
-
-# ServiceRegistry contract address and ABI
-SERVICE_REGISTRY_ADDRESS = "0x3d77596beb0f130a4415df3D2D8232B3d3D31e44"
-SERVICE_REGISTRY_ABI = [
-    # Include the ABI for the functions you need
-    # totalSupply() and getService(uint256)
-    {
-        "constant": True,
-        "inputs": [],
-        "name": "totalSupply",
-        "outputs": [{"name": "", "type": "uint256"}],
-        "type": "function",
-    },
-    {
-        "constant": True,
-        "inputs": [{"name": "serviceId", "type": "uint256"}],
-        "name": "getService",
-        "outputs": [
-            {"name": "owner", "type": "address"},
-            {"name": "multisig", "type": "address"},
-            {"name": "agentInstances", "type": "address[]"},
-            {"name": "threshold", "type": "uint32"},
-            {"name": "bonds", "type": "uint256[]"},
-            {"name": "agentIds", "type": "uint256[]"},
-            {"name": "state", "type": "uint8"},
-        ],
-        "type": "function",
-    },
-]
-
-# Gnosis Safe ABI (for getting the nonce)
-SAFE_ABI = [
-    {
-        "constant": True,
-        "inputs": [],
-        "name": "nonce",
-        "outputs": [{"name": "", "type": "uint256"}],
-        "type": "function",
-    },
-]
-
-def fetch_services():
-    w3 = Web3(Web3.HTTPProvider(OPTIMISM_RPC))
-    w3.middleware_onion.inject(geth_poa_middleware, layer=0)  # For Optimism
-
-    service_registry = w3.eth.contract(
-        address=Web3.toChecksumAddress(SERVICE_REGISTRY_ADDRESS),
-        abi=SERVICE_REGISTRY_ABI,
-    )
-
-    total_services = service_registry.functions.totalSupply().call()
-    print(f"Total services: {total_services}")
-
-    services_data = []
-    for service_id in range(1, total_services + 1):
-        service = service_registry.functions.getService(service_id).call()
-        owner = service[0]
-        multisig = service[1]
-        agent_ids = service[5]  # List of agent IDs
-        state = service[6]
-
-        # Filter for Optimus services (agentId == 25)
-        if 25 in agent_ids:
-            # Get the registration block number (we need to get the block number of the transaction that created the service)
-            # Since we don't have a subgraph, we'll approximate by using the block number of the latest transaction involving the service multisig
-            # Note: This is a simplification and may not be accurate
-            # For accurate results, a subgraph or indexed data is recommended
-            services_data.append({
-                "service_id": service_id,
-                "owner": owner,
-                "multisig": multisig,
-                "agent_ids": agent_ids,
-                "state": state,
-            })
-
-    return services_data
-
-def fetch_service_creation_dates(services_data):
-    w3 = Web3(Web3.HTTPProvider(OPTIMISM_RPC))
-    w3.middleware_onion.inject(geth_poa_middleware, layer=0)  # For Optimism
-
-    # Since we don't have direct access to service creation dates, we'll need to fetch historical logs
-    # Unfortunately, without a subgraph or an indexer, this is impractical for a large number of services
-    # As an alternative, we can skip this step or set approximate dates
-
-    # For demonstration, we'll set all registration dates to today
-    for service in services_data:
-        service["registration_date"] = datetime.utcnow().date()
-
-    return services_data
-
-def check_service_transactions(services_data):
-    w3 = Web3(Web3.HTTPProvider(OPTIMISM_RPC))
-    w3.middleware_onion.inject(geth_poa_middleware, layer=0)  # For Optimism
-
-    for service in services_data:
-        multisig_address = service["multisig"]
-        safe_contract = w3.eth.contract(
-            address=multisig_address,
-            abi=SAFE_ABI,
-        )
-        try:
-            nonce = safe_contract.functions.nonce().call()
-            service["nonce"] = nonce
-        except Exception as e:
-            # If the multisig is not a Gnosis Safe or the call fails
-            service["nonce"] = 0
-
-    return services_data
-
-def process_services_data(services_data):
-    # Convert to DataFrame
-    df = pd.DataFrame(services_data)
-
-    # Convert registration_date to datetime
-    df["registration_date"] = pd.to_datetime(df["registration_date"])
-
-    # Add week number
-    df["week"] = df["registration_date"].dt.strftime('%Y-%W')
-
-    # Determine if service has made at least one transaction
-    df["has_transaction"] = df["nonce"] > 0
-
+from datetime import datetime
+
+# Function to fetch and process the transaction data from the API
+def fetch_transactions():
+    url = "https://li.quest/v1/analytics/transfers?integrator=valory"
+    headers = {"accept": "application/json"}
+    response = requests.get(url, headers=headers)
+    return response.json()
+
+# Function to parse the transaction data and prepare it for visualization
+def process_transactions(data):
+    transactions = data["transfers"]
+
+    # Convert the data into a pandas DataFrame for easy manipulation
+    rows = []
+    for tx in transactions:
+        # Normalize amounts
+        sending_amount = float(tx["sending"]["amount"]) / (10 ** tx["sending"]["token"]["decimals"])
+        receiving_amount = float(tx["receiving"]["amount"]) / (10 ** tx["receiving"]["token"]["decimals"])
+
+        # Convert timestamps to datetime objects
+        sending_timestamp = datetime.utcfromtimestamp(tx["sending"]["timestamp"])
+        receiving_timestamp = datetime.utcfromtimestamp(tx["receiving"]["timestamp"])
+
+        # Prepare row data
+        rows.append({
+            "transactionId": tx["transactionId"],
+            "from_address": tx["fromAddress"],
+            "to_address": tx["toAddress"],
+            "sending_chain": tx["sending"]["chainId"],
+            "receiving_chain": tx["receiving"]["chainId"],
+            "sending_token_symbol": tx["sending"]["token"]["symbol"],
+            "receiving_token_symbol": tx["receiving"]["token"]["symbol"],
+            "sending_amount": sending_amount,
+            "receiving_amount": receiving_amount,
+            "sending_amount_usd": float(tx["sending"]["amountUSD"]),
+            "receiving_amount_usd": float(tx["receiving"]["amountUSD"]),
+            "sending_gas_used": int(tx["sending"]["gasUsed"]),
+            "receiving_gas_used": int(tx["receiving"]["gasUsed"]),
+            "sending_timestamp": sending_timestamp,
+            "receiving_timestamp": receiving_timestamp,
+            "date": sending_timestamp.date(),  # Group by day
+            "week": sending_timestamp.strftime('%Y-%W')  # Group by week
+        })
+    
+    df = pd.DataFrame(rows)
     return df
 
-def create_services_visualizations(df):
-    # 1) Number of services registered WoW
-    services_registered = df.groupby("week").size().reset_index(name="services_registered")
-    fig_services_registered = px.bar(services_registered, x="week", y="services_registered",
-                                     title="Number of Services Registered WoW")
-
-    # 2) Number of services making at least one transaction WoW
-    services_with_tx = df[df["has_transaction"]].groupby("week").size().reset_index(name="services_with_transaction")
-    fig_services_with_tx = px.bar(services_with_tx, x="week", y="services_with_transaction",
-                                  title="Number of Services with at Least One Transaction WoW")
-
-    return fig_services_registered, fig_services_with_tx
-
-# Integrate with the existing dashboard
+# Function to create visualizations based on the metrics
+def create_visualizations():
+    transactions_data = fetch_transactions()
+    df = process_transactions(transactions_data)
+
+    # Ensure that chain IDs are strings for consistent grouping
+    df["sending_chain"] = df["sending_chain"].astype(str)
+    df["receiving_chain"] = df["receiving_chain"].astype(str)
+
+    # 1. Number of Transactions per Chain per Day per Agent
+    tx_per_chain_agent = df.groupby(["date", "from_address", "sending_chain"]).size().reset_index(name="transaction_count")
+    fig_tx_chain_agent = px.bar(tx_per_chain_agent, x="date", y="transaction_count", color="sending_chain", barmode="group",
+                                facet_col="from_address", title="Number of Transactions per Chain per Agent per Day")
+
+    # 2. Number of Opportunities Taken per Agent per Day
+    opportunities_per_agent = df.groupby(["date", "from_address"]).size().reset_index(name="opportunities_taken")
+    fig_opportunities_agent = px.bar(opportunities_per_agent, x="date", y="opportunities_taken", color="from_address",
+                                     title="Number of Opportunities Taken per Agent per Day")
+
+    # 3. Amount of Investment in Pools Daily per Agent (Note: Assuming sending_amount_usd as investment)
+    # Since we might not have explicit data about pool investments, we'll use sending_amount_usd
+    investment_per_agent = df.groupby(["date", "from_address"])["sending_amount_usd"].sum().reset_index()
+    fig_investment_agent = px.bar(investment_per_agent, x="date", y="sending_amount_usd", color="from_address",
+                                  title="Amount of Investment (USD) per Agent per Day")
+
+    # 4. Number of Swaps per Day
+    # Assuming each transaction is a swap if sending and receiving tokens are different
+    df["is_swap"] = df.apply(lambda x: x["sending_token_symbol"] != x["receiving_token_symbol"], axis=1)
+    swaps_per_day = df[df["is_swap"]].groupby("date").size().reset_index(name="swap_count")
+    fig_swaps_per_day = px.bar(swaps_per_day, x="date", y="swap_count", title="Number of Swaps per Day")
+
+    # 5. Aggregated Metrics over All Traders
+    amount_usd = df["sending_amount_usd"]
+    stats = {
+        "Total": amount_usd.sum(),
+        "Average": amount_usd.mean(),
+        "Min": amount_usd.min(),
+        "Max": amount_usd.max(),
+        "25th Percentile": amount_usd.quantile(0.25),
+        "50th Percentile (Median)": amount_usd.median(),
+        "75th Percentile": amount_usd.quantile(0.75),
+    }
+    stats_df = pd.DataFrame(list(stats.items()), columns=["Metric", "Value"])
+
+    # Visualization for Aggregated Metrics
+    fig_stats = px.bar(stats_df, x="Metric", y="Value", title="Aggregated Transaction Amount Metrics (USD)")
+
+    return fig_tx_chain_agent, fig_opportunities_agent, fig_investment_agent, fig_swaps_per_day, fig_stats
+
+# Gradio interface
 def dashboard():
     with gr.Blocks() as demo:
         gr.Markdown("# Valory Transactions Dashboard")
 
-        # Existing visualizations
+        # Fetch and display visualizations
         with gr.Tab("Transactions per Chain per Agent"):
             fig_tx_chain_agent, _, _, _, _ = create_visualizations()
             gr.Plot(fig_tx_chain_agent)
@@ -171,20 +124,10 @@ def dashboard():
         with gr.Tab("Aggregated Metrics"):
             _, _, _, _, fig_stats = create_visualizations()
             gr.Plot(fig_stats)
-
-        # New visualizations for services
-        with gr.Tab("Services Registered WoW"):
-            services_data = fetch_services()
-            services_data = fetch_service_creation_dates(services_data)
-            services_data = check_service_transactions(services_data)
-            df_services = process_services_data(services_data)
-            fig_services_registered, fig_services_with_tx = create_services_visualizations(df_services)
-            gr.Plot(fig_services_registered)
-        
-        with gr.Tab("Services with Transactions WoW"):
-            gr.Plot(fig_services_with_tx)
     
     return demo
 
+# Launch the dashboard
 if __name__ == "__main__":
     dashboard().launch()
+