From 17ecd4af14c3eb8f5298e4bdc386b164d7e3018b Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 12:38:34 +0200 Subject: [PATCH 01/10] feat: roi analyisis notebook --- notebooks/generate_roi_analysis_dataset.py | 209 +++++++++++ notebooks/roi_analysis.ipynb | 408 +++++++++++++++++++++ notebooks/sample.env | 4 + tox.ini | 15 +- 4 files changed, 630 insertions(+), 6 deletions(-) create mode 100644 notebooks/generate_roi_analysis_dataset.py create mode 100644 notebooks/roi_analysis.ipynb create mode 100644 notebooks/sample.env diff --git a/notebooks/generate_roi_analysis_dataset.py b/notebooks/generate_roi_analysis_dataset.py new file mode 100644 index 0000000..97bddce --- /dev/null +++ b/notebooks/generate_roi_analysis_dataset.py @@ -0,0 +1,209 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# ------------------------------------------------------------------------------ +# +# Copyright 2023-2024 Valory AG +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# ------------------------------------------------------------------------------ + +""" +Generates dataset for ROI analysis +""" + +# pylint: disable=wrong-import-position + +import argparse +import bisect +import json +import os +import sys +from pathlib import Path +from typing import Any, Dict, List + +import requests +from dotenv import dotenv_values +from web3 import Web3 + +SCRIPT_PATH = Path(__file__).resolve().parent +DOTENV_PATH = Path(SCRIPT_PATH, ".env") + +env_file_vars = dotenv_values(DOTENV_PATH) +trader_quickstart_path = env_file_vars.get("TRADER_QUICKSTART_PATH") + +sys.path.insert(0, '../scripts') +sys.path.insert(0, os.path.expanduser(trader_quickstart_path)) +sys.path.insert(0, os.path.expanduser(f"{trader_quickstart_path}/scripts")) + +import trades +from mech_request_utils import get_mech_requests +from trades import INVALID_ANSWER, MarketState, TradeResult + +RPC = env_file_vars.get("RPC") +SERVICE_REGISTRY_ADDRESS = "0x9338b5153AE39BB89f50468E608eD9d764B755fD" + + +def _get_contract(address: str) -> Any: + w3 = Web3(Web3.HTTPProvider(RPC)) + abi = _get_abi(address) + contract = w3.eth.contract(address=Web3.to_checksum_address(address), abi=abi) + return contract + + +def _get_abi(address: str) -> List: + contract_abi_url = ( + "https://gnosis.blockscout.com/api/v2/smart-contracts/{contract_address}" + ) + response = requests.get(contract_abi_url.format(contract_address=address)).json() + + if "result" in response: + result = response["result"] + try: + abi = json.loads(result) + except json.JSONDecodeError: + print("Error: Failed to parse 'result' field as JSON") + sys.exit(1) + else: + abi = response.get("abi") + + return abi if abi else [] + + +def _populate_mech_requests( + fpmm_trades: Dict[str, Any], mech_requests: Dict[str, Any] +) -> List[str]: + """Populate each trade in trades_json with the corresponding mech_requests""" + + print("Populating mech requests...") + + # Sort mech requests by timestamp + dumped_mech_requests = list(mech_requests.values()) + sorted_mech_requests = sorted( + dumped_mech_requests, key=lambda x: int(x["blockTimestamp"]) + ) + timestamps = [int(x["blockTimestamp"]) for x in sorted_mech_requests] + + # TODO shallow copy for efficiency, be careful + outstanding_mech_requests = mech_requests.copy() + + for trade in fpmm_trades: + creation_timestamp = int(trade["creationTimestamp"]) + + # Find the mech request immediately before 'creationTimestamp' + idx = bisect.bisect_left(timestamps, creation_timestamp) - 1 + found = False + + if idx < 0: + print("ERROR: idx < 0") + continue + + N = 3 # Adjust N to the number of indices you want to check + for i in range(idx, max(0, idx - N), -1): + mech_request = sorted_mech_requests[i] + mech_request_id = mech_request["id"] + + if trade["title"] in mech_request["ipfsContents"]["prompt"]: + trade["mechRequestId"] = mech_request_id + del outstanding_mech_requests[mech_request_id] + found = True + if i != idx: + print( + f"WARNING: '{trade['title']}' was not found at idx={idx}, used idx={i} instead." + ) + break + + if not found: + print( + f"ERROR: '{trade['title']}' is not found in any mech request up to {N} indices before idx={idx}." + ) + print(f"{trade['id']=}") + + return list(outstanding_mech_requests.keys()) + + +def _populate_market_states(fpmm_trades: Dict[str, Any]) -> None: + print("Populating market states...") + + for trade in fpmm_trades: + fpmm = trade["fpmm"] + state = trades._get_market_state(fpmm) # pylint: disable=protected-access + fpmm["state"] = state.value + + if state == MarketState.CLOSED: + outcome_index = int(trade["outcomeIndex"]) + current_answer = int(fpmm["currentAnswer"], 16) + if current_answer == INVALID_ANSWER: + trade["result"] = TradeResult.INVALID.value + elif current_answer == outcome_index: + trade["result"] = TradeResult.WIN.value + else: + trade["result"] = TradeResult.LOSE.value + else: + trade["result"] = TradeResult.UNKNOWN.value + + +def get_service_safe(service_id: int) -> str: + """Gets the service Safe""" + service_registry = _get_contract(SERVICE_REGISTRY_ADDRESS) + service_safe_address = service_registry.functions.getService(service_id).call()[1] + return service_safe_address + + +def generate_dataset(service_id: int) -> (Dict[str, Any], Dict[str, Any], List[str]): + """Generates the dataset""" + dataset_json = f"dataset_{service_id}.json" + + service_safe_address = get_service_safe(service_id) + + print(f"{service_id=}") + print(f"{service_safe_address=}") + print(service_safe_address.lower()) + + mech_requests = get_mech_requests(service_safe_address, dataset_json) + + fpmm_trades = trades._query_omen_xdai_subgraph(service_safe_address.lower())[ # pylint: disable=protected-access + "data" + ]["fpmmTrades"] + outstanding_mech_request_ids = _populate_mech_requests(fpmm_trades, mech_requests) + _populate_market_states(fpmm_trades) + + try: + with open(dataset_json, "r", encoding="utf-8") as file: + data = json.load(file) + except (FileNotFoundError, json.JSONDecodeError): + data = {} + + data["fpmmTrades"] = fpmm_trades + data["outstandingMechRequestIds"] = outstanding_mech_request_ids + + with open(dataset_json, "w", encoding="utf-8") as file: + json.dump(data, file, indent=2, sort_keys=True) + + print(f"Finished generating datasets for service {service_id}") + print("") + print("Finished reading dataset:") + print(f" - {len(fpmm_trades)} trades") + print(f" - {len(mech_requests)} mech requests") + print(f" - {len(outstanding_mech_request_ids)} outstanding mech requests") + + return fpmm_trades, mech_requests, outstanding_mech_request_ids + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Generate dataset for a specific service." + ) + parser.add_argument("service_id", type=int, help="Service ID is required.") + args = parser.parse_args() + generate_dataset(args.service_id) diff --git a/notebooks/roi_analysis.ipynb b/notebooks/roi_analysis.ipynb new file mode 100644 index 0000000..356b19c --- /dev/null +++ b/notebooks/roi_analysis.ipynb @@ -0,0 +1,408 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import ipywidgets as widgets\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import sys\n", + "import os\n", + "import requests\n", + "import pandas as pd\n", + "import pytz\n", + "from collections import defaultdict, Counter\n", + "from datetime import datetime, timedelta, timezone\n", + "from dotenv import dotenv_values\n", + "from IPython.display import display, HTML\n", + "\n", + "# Create a local \".env\" file containing the variables\n", + "#\n", + "# RPC=\n", + "# SUBGRAPH_API_KEY=\n", + "# GNOSISSCAN_API_KEY= (optional, just used for the last part of the Notebook)\n", + "# TRADER_QUICKSTART_PATH=\n", + "DOTENV_PATH = \".env\"\n", + "\n", + "env_file_vars = dotenv_values(DOTENV_PATH)\n", + "trader_quickstart_path = env_file_vars.get(\"TRADER_QUICKSTART_PATH\")\n", + "\n", + "sys.path.insert(0, '../scripts')\n", + "sys.path.insert(0, os.path.expanduser(trader_quickstart_path))\n", + "sys.path.insert(0, os.path.expanduser(f\"{trader_quickstart_path}/scripts\"))\n", + "\n", + "import generate_roi_analysis_dataset\n", + "from trades import MarketState, TradeResult, INVALID_ANSWER, _compute_roi\n", + "\n", + "def annotate_bars(ax):\n", + " \"\"\"Annotates each bar in the given axis with its height value.\"\"\"\n", + " for p in ax.patches:\n", + " ax.annotate(f'{int(p.get_height())}', \n", + " (p.get_x() + p.get_width() / 2., p.get_height()), \n", + " ha='center', va='center', \n", + " xytext=(0, 5), \n", + " textcoords='offset points')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Edit these parameters accordingly\n", + "\n", + "service_id = 335\n", + "start_date_str = \"2024-03-01T00:00:01Z\"\n", + "end_date_str = \"2024-09-16T23:59:59Z\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "service_safe_address = generate_roi_analysis_dataset.get_service_safe(service_id)\n", + "\n", + "print(f\"{service_id=}\")\n", + "print(f\"{service_safe_address=}\")\n", + "\n", + "dataset_json = f\"dataset_{service_id}.json\"\n", + "\n", + "generate_roi_analysis_dataset.generate_dataset(service_id)\n", + "\n", + "with open(dataset_json, 'r') as file:\n", + " data = json.load(file)\n", + " mech_requests = data[\"mechRequests\"]\n", + " fpmm_trades = data[\"fpmmTrades\"]\n", + " outstanding_mech_request_ids = data[\"outstandingMechRequestIds\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Transform to a Dataframe\n", + "\n", + "df = pd.json_normalize(fpmm_trades)\n", + "\n", + "df['creationTimestamp'] = pd.to_numeric(df['creationTimestamp'], errors='coerce')\n", + "\n", + "df['result'] = df['result'].map(TradeResult)\n", + "df['result'] = pd.Categorical(df['result'])\n", + "\n", + "df['fpmm.state'] = df['fpmm.state'].map(lambda x: MarketState(x).name.lower())\n", + "df['fpmm.state'] = pd.Categorical(df['fpmm.state'])\n", + "\n", + "df['mechTool'] = df['mechRequestId'].map(lambda x: mech_requests[x]['ipfsContents']['tool'])\n", + "\n", + "df['deliver.confidence'] = df['mechRequestId'].map(lambda x: json.loads(mech_requests[x]['deliver']['ipfsContents']['result'])['confidence'])\n", + "df['deliver.p_yes'] = df['mechRequestId'].map(lambda x: json.loads(mech_requests[x]['deliver']['ipfsContents']['result'])['p_yes'])\n", + "\n", + "df['collateralAmount'] = df['collateralAmount'].astype(float) / 1e18\n", + "df['outcomeTokensTraded'] = df['outcomeTokensTraded'].astype(float) / 1e18\n", + "df['feeAmount'] = df['feeAmount'].astype(float) / 1e18\n", + "\n", + "# Display a few columns and rows\n", + "df_selected = df[['id', 'outcomeTokensTraded', 'fpmm.state', 'result', 'mechTool', 'deliver.confidence', 'deliver.p_yes']]\n", + "display(HTML(df_selected.head(5).to_html(index=False)))\n", + "print(df.columns)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Filter dataset\n", + "\n", + "start_timestamp = datetime.fromisoformat(start_date_str.replace(\"Z\", \"+00:00\")).timestamp()\n", + "end_timestamp = datetime.fromisoformat(end_date_str.replace(\"Z\", \"+00:00\")).timestamp()\n", + "\n", + "print(f\"Total trades: {len(df)}\")\n", + "\n", + "# Filter by selected dates\n", + "df = df[(df['creationTimestamp'] >= start_timestamp) & (df['creationTimestamp'] <= end_timestamp)]\n", + "print(f\"Start date: {start_date_str}\")\n", + "print(f\"End date: {end_date_str}\")\n", + "print(f\"Filtered by date: {len(df)}\")\n", + "\n", + "# Filter by closed state\n", + "df = df[df['fpmm.state'] == 'closed']\n", + "print(f\"Filtered by state: {len(df)}\")\n", + "print(\"\")\n", + "\n", + "# Filter outstanding mech requests\n", + "print(f\"Total outstanding mech requests: {len(outstanding_mech_request_ids)}\")\n", + "\n", + "outstanding_mech_request_ids = [request_id for request_id in outstanding_mech_request_ids \n", + " if start_timestamp <= int(mech_requests[request_id]['blockTimestamp']) <= end_timestamp]\n", + "print(f\"Filtered by date: {len(outstanding_mech_request_ids)}\")\n", + "\n", + "print(\"\")\n", + "print(f\"Summary of period {start_date_str} - {end_date_str}\")\n", + "print(\"-------------------------------------------------------------\")\n", + "\n", + "investment = df['collateralAmount'].sum()\n", + "market_fees = df['feeAmount'].sum()\n", + "mech_fees = 0.01 * len(df)\n", + "outstanding_mech_fees = 0.01 * len(outstanding_mech_request_ids)\n", + "win_earnings = df[df['result'] == TradeResult.WIN]['outcomeTokensTraded'].sum()\n", + "invalid_earnings = df[df['result'] == TradeResult.INVALID]['collateralAmount'].sum()\n", + "\n", + "roi = _compute_roi(\n", + " investment + market_fees + mech_fees + outstanding_mech_fees,\n", + " win_earnings + invalid_earnings\n", + ")\n", + "\n", + "print(f\"Total trades: {len(df)}\")\n", + "\n", + "print(\"counts:\")\n", + "result_counts = df['result'].value_counts()\n", + "print(result_counts)\n", + "print(\"\")\n", + "\n", + "\n", + "# Sum the 'outcomeTokensTraded' per result type\n", + "print(\"collateralAmount:\")\n", + "outcome_sums = df.groupby('result', observed=False)['collateralAmount'].sum()\n", + "print(outcome_sums)\n", + "\n", + "\n", + "\n", + "print(f\"{investment= }\")\n", + "print(f\"{market_fees= }\")\n", + "print(f\"{mech_fees= }\")\n", + "print(f\"{outstanding_mech_fees= }\")\n", + "print(f\"{win_earnings= }\")\n", + "print(f\"{invalid_earnings= }\")\n", + "print(\"\")\n", + "print(f\"{roi=}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Display count by state\n", + "result_counts = df['result'].value_counts()\n", + "#print(result_counts)\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "ax = sns.barplot(x=result_counts.index, y=result_counts.values, palette='viridis', hue=result_counts.index)\n", + "annotate_bars(ax)\n", + "plt.title(\"Distribution of Trades for Closed State\")\n", + "plt.xlabel(\"Result\")\n", + "plt.ylabel(\"Count\")\n", + "plt.show()\n", + "\n", + "# Count occurrences of each mech_tool\n", + "mech_tool_counts = df['mechTool'].value_counts()\n", + "plt.figure(figsize=(10, 5))\n", + "ax = sns.barplot(x=mech_tool_counts.index, y=mech_tool_counts.values, palette='viridis', hue=mech_tool_counts.index)\n", + "annotate_bars(ax)\n", + "plt.title(\"Count of Each MechTool Used\")\n", + "plt.xlabel(\"MechTool\")\n", + "plt.xticks(rotation=90)\n", + "plt.ylabel(\"Count\")\n", + "plt.show()\n", + "\n", + "# Count occurrences of each mech_tool per result\n", + "mech_tool_counts = df.groupby(['result', 'mechTool'], observed=False).size().reset_index(name='count')\n", + "plt.figure(figsize=(10, 5))\n", + "ax = sns.barplot(x='result', y='count', hue='mechTool', data=mech_tool_counts, palette='husl')\n", + "annotate_bars(ax)\n", + "plt.title(\"Count of Each MechTool Used per Market Result\")\n", + "plt.xlabel(\"Market Result\")\n", + "plt.ylabel(\"Count\")\n", + "plt.show()\n", + "\n", + "# Count the number of trades per market\n", + "trades_per_market = df.groupby('fpmm.id').size()\n", + "market_counts = trades_per_market.value_counts().sort_index().reset_index()\n", + "market_counts.columns = ['Number of Trades', 'Number of Markets']\n", + "plt.figure(figsize=(10, 5))\n", + "ax = sns.barplot(x='Number of Trades', y='Number of Markets', data=market_counts, palette='husl', hue='Number of Trades')\n", + "annotate_bars(ax)\n", + "plt.title('Histogram of Number of Markets by Trades Count')\n", + "plt.xlabel('Number of Trades')\n", + "plt.ylabel('Number of Markets')\n", + "plt.grid(axis='y')\n", + "plt.show()\n", + "\n", + "\n", + "# Find the market with the maximum number of trades\n", + "max_trades_market = trades_per_market.idxmax() # Get the fpmm_id with the highest count\n", + "max_trades_count = trades_per_market.max() # Get the highest count of trades\n", + "\n", + "print(f\"Market with the highest number of trades: {max_trades_market} ({max_trades_count} trades)\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot histogram\n", + "plt.figure(figsize=(10, 6))\n", + "sns.histplot(df['outcomeTokensTraded'], bins=50)\n", + "plt.title('Histogram of Outcome Tokens Traded')\n", + "plt.xlabel('Outcome Tokens Traded (ETH)')\n", + "plt.ylabel('Frequency')\n", + "plt.grid(True)\n", + "plt.show()\n", + "print(\"Market with max. outcomeTokensTraded \")\n", + "max_id = df.loc[df['outcomeTokensTraded'].idxmax(), 'id']\n", + "print(max_id)\n", + "print(df['outcomeTokensTraded'].max())\n", + "\n", + "# Plot histogram\n", + "plt.figure(figsize=(10, 6))\n", + "sns.histplot(df['collateralAmount'], bins=50)\n", + "plt.title('Histogram of Collateral Amount')\n", + "plt.xlabel('Collateral Amount (ETH)')\n", + "plt.ylabel('Frequency')\n", + "plt.grid(True)\n", + "plt.show()\n", + "print(\"Market with max. collateralAmount \")\n", + "max_id = df.loc[df['collateralAmount'].idxmax(), 'id']\n", + "print(max_id)\n", + "print(df['collateralAmount'].max())\n", + "\n", + "\n", + "# Create grid for histograms\n", + "g = sns.FacetGrid(df, col='result', col_wrap=4, height=4)\n", + "g.map(sns.histplot, 'collateralAmount', bins=50)\n", + "g.set_axis_labels('Collateral Amount (ETH)', 'Frequency')\n", + "plt.show()\n", + "\n", + "# Create grid for histograms\n", + "g = sns.FacetGrid(df, col='result', col_wrap=4, height=4)\n", + "g.map(sns.histplot, 'outcomeTokensTraded', bins=50)\n", + "g.set_axis_labels('Outcome Tokens Traded (ETH)', 'Frequency')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Plot histogram of confidence (total)\n", + "plt.figure(figsize=(10, 6))\n", + "sns.histplot(df['deliver.confidence'], bins=50)\n", + "plt.title('Histogram of Confidence (Total)')\n", + "plt.xlabel('Confidence')\n", + "plt.ylabel('Frequency')\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Plot histogram of p_yes (total)\n", + "plt.figure(figsize=(10, 6))\n", + "sns.histplot(df['deliver.p_yes'], bins=50)\n", + "plt.title('Histogram of p_yes (Total)')\n", + "plt.xlabel('Confidence')\n", + "plt.ylabel('Frequency')\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Create grid for histograms of confidence per market state\n", + "g = sns.FacetGrid(df, col='result', col_wrap=4, height=4)\n", + "g.map(sns.histplot, 'deliver.confidence', bins=50)\n", + "g.set_axis_labels('Confidence', 'Frequency')\n", + "plt.show()\n", + "\n", + "# Create grid for histograms of p_yes per market state\n", + "g = sns.FacetGrid(df, col='result', col_wrap=4, height=4)\n", + "g.map(sns.histplot, 'deliver.p_yes', bins=50)\n", + "g.set_axis_labels('p_yes', 'Frequency')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# GnosisScan URL to get transaction history\n", + "gnosisscan_api_key = env_file_vars.get(\"GNOSISSCAN_API_KEY\")\n", + "url = f\"https://api.gnosisscan.io/api?module=account&action=txlist&address={service_safe_address}&startblock=0&endblock=99999999&sort=asc&apikey={gnosisscan_api_key}\"\n", + "response = requests.get(url)\n", + "data = response.json()\n", + "\n", + "if data['status'] == '1':\n", + " transactions = data['result']\n", + "else:\n", + " print(\"Error fetching data:\", data['message'])\n", + " transactions = []\n", + "\n", + "# Initialize lists to store balance over time\n", + "timestamps = []\n", + "balances = []\n", + "\n", + "# Track the balance over time\n", + "balance = 0 # in wei\n", + "for tx in transactions:\n", + " timestamp = datetime.utcfromtimestamp(int(tx['timeStamp']))\n", + " timestamps.append(timestamp)\n", + "\n", + " value = int(tx['value']) # value in wei\n", + " if tx['to'].lower() == service_safe_address.lower():\n", + " balance += value # Incoming transaction\n", + " elif tx['from'].lower() == service_safe_address.lower():\n", + " balance -= value # Outgoing transaction\n", + " \n", + " # Convert from wei to ether (or native token like xDAI) and store balance\n", + " balances.append(balance / 10**18)\n", + "\n", + "# Plot the balance over time\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(timestamps, balances)\n", + "plt.title(f'Refills Over Time for {service_safe_address} on Gnosis Chain')\n", + "plt.xlabel('Time')\n", + "plt.ylabel('Balance (xDAI or GNO)')\n", + "plt.xticks(rotation=45)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "market-creator-nnXotJ75-py3.10", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/sample.env b/notebooks/sample.env new file mode 100644 index 0000000..c4af800 --- /dev/null +++ b/notebooks/sample.env @@ -0,0 +1,4 @@ +RPC= +SUBGRAPH_API_KEY= +GNOSISSCAN_API_KEY= +TRADER_QUICKSTART_PATH= diff --git a/tox.ini b/tox.ini index 9692074..b231da8 100644 --- a/tox.ini +++ b/tox.ini @@ -155,19 +155,20 @@ deps = tomte[bandit]==0.2.14 commands = bandit -s B101 -r {env:SERVICE_SPECIFIC_PACKAGES} bandit -s B101 -r scripts + bandit -s B101 -r notebooks bandit -s B101 -r market_approval_server [testenv:black] skipsdist = True skip_install = True deps = tomte[black]==0.2.14 -commands = black {env:SERVICE_SPECIFIC_PACKAGES} scripts market_approval_server +commands = black {env:SERVICE_SPECIFIC_PACKAGES} scripts notebooks market_approval_server [testenv:black-check] skipsdist = True skip_install = True deps = tomte[black]==0.2.14 -commands = black --check {env:SERVICE_SPECIFIC_PACKAGES} scripts market_approval_server +commands = black --check {env:SERVICE_SPECIFIC_PACKAGES} scripts notebooks market_approval_server [testenv:isort] skipsdist = True @@ -176,13 +177,14 @@ deps = tomte[isort]==0.2.14 commands = isort {env:SERVICE_SPECIFIC_PACKAGES} --gitignore isort scripts/ + isort notebooks/ isort market_approval_server/ [testenv:isort-check] skipsdist = True skip_install = True deps = tomte[isort]==0.2.14 -commands = isort --check-only --gitignore {env:SERVICE_SPECIFIC_PACKAGES} scripts market_approval_server +commands = isort --check-only --gitignore {env:SERVICE_SPECIFIC_PACKAGES} scripts notebooks market_approval_server [testenv:check-hash] skipsdist = True @@ -213,6 +215,7 @@ deps = tomte[flake8]==0.2.14 commands = flake8 {env:SERVICE_SPECIFIC_PACKAGES} flake8 scripts + flake8 notebooks flake8 market_approval_server [testenv:mypy] @@ -230,7 +233,7 @@ skipsdist = True deps = {[deps-packages]deps} tomte[pylint]==0.2.15 -commands = pylint --ignore-patterns=".*_pb2.py" --ignore-paths="^packages/valory/.*$" --disable=C0103,R0801,R0912,C0301,C0201,C0204,C0209,W1203,C0302,R1735,R1729,W0511,E0401 {env:SERVICE_SPECIFIC_PACKAGES} scripts market_approval_server +commands = pylint --ignore-patterns=".*_pb2.py" --ignore-paths="^packages/valory/.*$" --disable=C0103,R0801,R0912,C0301,C0201,C0204,C0209,W1203,C0302,R1735,R1729,W0511,E0401 {env:SERVICE_SPECIFIC_PACKAGES} scripts notebooks market_approval_server [testenv:safety] skipsdist = True @@ -242,7 +245,7 @@ commands = safety check -i 37524 -i 38038 -i 37776 -i 38039 -i 39621 -i 40291 -i skipsdist = True skip_install = True deps = tomte[darglint]==0.2.14 -commands = darglint scripts market_approval_server {env:SERVICE_SPECIFIC_PACKAGES}/* +commands = darglint scripts notebooks market_approval_server {env:SERVICE_SPECIFIC_PACKAGES}/* [testenv:check-generate-all-protocols] skipsdist = True @@ -306,7 +309,7 @@ exclude=.md, max-line-length = 88 select = B,C,D,E,F,I,W, ignore = E203,E501,W503,D202,B014,D400,D401,DAR -application-import-names = packages,tests,scripts,market_approval_server +application-import-names = packages,tests,scripts,notebooks,market_approval_server # ignore as too restrictive for our needs: # D400: First line should end with a period From ba25dbc29f1b801fdd5d4d08a519c8fb8a97a325 Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 13:22:29 +0200 Subject: [PATCH 02/10] chore: update instructions --- notebooks/generate_roi_analysis_dataset.py | 3 +- notebooks/roi_analysis.ipynb | 468 +++++++++++++++++++-- 2 files changed, 443 insertions(+), 28 deletions(-) diff --git a/notebooks/generate_roi_analysis_dataset.py b/notebooks/generate_roi_analysis_dataset.py index 97bddce..35577de 100644 --- a/notebooks/generate_roi_analysis_dataset.py +++ b/notebooks/generate_roi_analysis_dataset.py @@ -52,6 +52,7 @@ RPC = env_file_vars.get("RPC") SERVICE_REGISTRY_ADDRESS = "0x9338b5153AE39BB89f50468E608eD9d764B755fD" +DATASET_PREFIX = "roi_analysis_dataset_" def _get_contract(address: str) -> Any: @@ -162,7 +163,7 @@ def get_service_safe(service_id: int) -> str: def generate_dataset(service_id: int) -> (Dict[str, Any], Dict[str, Any], List[str]): """Generates the dataset""" - dataset_json = f"dataset_{service_id}.json" + dataset_json = f"{DATASET_PREFIX}{service_id}.json" service_safe_address = get_service_safe(service_id) diff --git a/notebooks/roi_analysis.ipynb b/notebooks/roi_analysis.ipynb index 356b19c..1ad092d 100644 --- a/notebooks/roi_analysis.ipynb +++ b/notebooks/roi_analysis.ipynb @@ -1,8 +1,72 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Trader ROI analysis notebook\n", + "\n", + "## How to run this notebook\n", + "1. Clone locally trader quickstart repository https://github.com/valory-xyz/trader-quickstart (branch main)\n", + "2. Clone locally market creator repository https://github.com/valory-xyz/market-creator (branch feat/roi_analysis). The rest of the steps occur on the market creator repository.\n", + "3. Poetry install\n", + " ```bash\n", + " cd market-creator\n", + " poetry shell\n", + " poetry install\n", + " ```\n", + "\n", + "4. Copy the file sample.env to .env\n", + "\n", + " ```bash\n", + " cd notebooks\n", + " cp sample.env .env\n", + " ```\n", + "\n", + "5. Populate the variables inside the .env file. The variable `GNOSISSCAN_API_KEY` is only required for the last part of the notebook. Fill to a dummy value if you don’t want to use it.\n", + "\n", + " ```bash\n", + " RPC=\n", + " SUBGRAPH_API_KEY=\n", + " GNOSISSCAN_API_KEY=\n", + " TRADER_QUICKSTART_PATH=\n", + " ```\n", + "\n", + "6. The first time you want to run an analysis for a service, it’s recommended that you create the dataset outside the notebook as follows:\n", + " \n", + " ```bash\n", + " python generate_roi_analysis_dataset.py 327\n", + " ```\n", + "\n", + " If you are collecting a lot of data, it might take a while to generate the dataset, and you might need to run the scripts multiple times, due to network errors.\n", + " As a result of this step you should end with a file called `roi_analysis_dataset_.json`\n", + "\n", + "7. Edit the cell of this notebook with the required data\n", + "\n", + " ```python\n", + " # Edit these parameters accordingly\n", + " service_id = 335\n", + " start_date_str = \"2024-03-01T00:00:01Z\"\n", + " end_date_str = \"2024-09-16T23:59:59Z\"\n", + " ```\n", + "\n", + "8. Run the notebook.\n", + "\n", + "Notes:\n", + "\n", + "- The dataset collection process collects the whole data for a service.\n", + "- The notebook will then filter for the specified date range and closed markets.\n", + "- Therefore, re-running the notebook will only update the trades/mech calls made since last running (should be a <1 minute process if less than 100 new trades or mech calls). \n", + "- For quickly usage, if you don’t want to re-collect data, simply comment the following line on the notebook:\n", + "\n", + " ```python\n", + " generate_dataset(service_id)\n", + " ```" + ] + }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -20,12 +84,6 @@ "from dotenv import dotenv_values\n", "from IPython.display import display, HTML\n", "\n", - "# Create a local \".env\" file containing the variables\n", - "#\n", - "# RPC=\n", - "# SUBGRAPH_API_KEY=\n", - "# GNOSISSCAN_API_KEY= (optional, just used for the last part of the Notebook)\n", - "# TRADER_QUICKSTART_PATH=\n", "DOTENV_PATH = \".env\"\n", "\n", "env_file_vars = dotenv_values(DOTENV_PATH)\n", @@ -35,7 +93,7 @@ "sys.path.insert(0, os.path.expanduser(trader_quickstart_path))\n", "sys.path.insert(0, os.path.expanduser(f\"{trader_quickstart_path}/scripts\"))\n", "\n", - "import generate_roi_analysis_dataset\n", + "from generate_roi_analysis_dataset import get_service_safe, generate_dataset, DATASET_PREFIX\n", "from trades import MarketState, TradeResult, INVALID_ANSWER, _compute_roi\n", "\n", "def annotate_bars(ax):\n", @@ -50,12 +108,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# Edit these parameters accordingly\n", - "\n", "service_id = 335\n", "start_date_str = \"2024-03-01T00:00:01Z\"\n", "end_date_str = \"2024-09-16T23:59:59Z\"" @@ -63,18 +120,85 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "service_id=335\n", + "service_safe_address='0x3c01B79BaD670A37C8784bDf47b973b341064f10'\n", + "service_id=335\n", + "service_safe_address='0x3c01B79BaD670A37C8784bDf47b973b341064f10'\n", + "0x3c01b79bad670a37c8784bdf47b973b341064f10\n", + " Fetching requests...\n", + " 16569 requests found\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " Fetching delivers: 100%|██████████| 1/1 [00:03<00:00, 3.39s/it]\n", + " Finding duplicate delivers: 100%|██████████| 16569/16569 [00:00<00:00, 116791.96it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Duplicate deliver ids found: 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " Processing duplicate delivers: 0it [00:00, ?it/s]\n", + " Finding duplicate delivers: 100%|██████████| 16569/16569 [00:00<00:00, 677019.97it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Duplicate deliver ids found: 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " Fetching IPFS contents: 0it [00:00, ?it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time of execution: 0:00:29.735739\n", + "Populating mech requests...\n", + "Populating market states...\n", + "Finished generating datasets for service 335\n", + "\n", + "Finished reading dataset:\n", + " - 2775 trades\n", + " - 16569 mech requests\n", + " - 13794 outstanding mech requests\n" + ] + } + ], "source": [ - "service_safe_address = generate_roi_analysis_dataset.get_service_safe(service_id)\n", + "service_safe_address = get_service_safe(service_id)\n", "\n", "print(f\"{service_id=}\")\n", "print(f\"{service_safe_address=}\")\n", "\n", - "dataset_json = f\"dataset_{service_id}.json\"\n", + "dataset_json = f\"{DATASET_PREFIX}{service_id}.json\"\n", "\n", - "generate_roi_analysis_dataset.generate_dataset(service_id)\n", + "# Comment this line to avoid updating the dataset\n", + "generate_dataset(service_id)\n", "\n", "with open(dataset_json, 'r') as file:\n", " data = json.load(file)\n", @@ -85,9 +209,98 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idoutcomeTokensTradedfpmm.stateresultmechTooldeliver.confidencedeliver.p_yes
0x47feda1a124caec341d8f60e5d524c77a76545a10x3c01b79bad670a37c8784bdf47b973b341064f100x10.286803closedWinprediction-online-sme0.80.15
0x02b29b4025d4bc4a93a24304a5bebaa930cd53e10x3c01b79bad670a37c8784bdf47b973b341064f100x20.203868closedWinprediction-online-sme0.80.30
0x703667dcd2860823fdcdabe4ed0b337efc17ab100x3c01b79bad670a37c8784bdf47b973b341064f100x30.214452closedWinprediction-online-sme0.80.30
0x703667dcd2860823fdcdabe4ed0b337efc17ab100x3c01b79bad670a37c8784bdf47b973b341064f100x5d0.226488closedWinprediction-online-sme0.80.30
0x9a2e0a075256fd2f21dfe8bbf1af7fdcd45b70f10x3c01b79bad670a37c8784bdf47b973b341064f100x40.213473closedWinprediction-online-sme0.80.30
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['collateralAmount', 'collateralAmountUSD', 'collateralToken',\n", + " 'creationTimestamp', 'feeAmount', 'id', 'mechRequestId',\n", + " 'oldOutcomeTokenMarginalPrice', 'outcomeIndex',\n", + " 'outcomeTokenMarginalPrice', 'outcomeTokensTraded', 'result', 'title',\n", + " 'transactionHash', 'type', 'creator.id',\n", + " 'fpmm.answerFinalizedTimestamp', 'fpmm.arbitrationOccurred',\n", + " 'fpmm.condition.id', 'fpmm.currentAnswer', 'fpmm.id',\n", + " 'fpmm.isPendingArbitration', 'fpmm.openingTimestamp', 'fpmm.outcomes',\n", + " 'fpmm.state', 'fpmm.title', 'mechTool', 'deliver.confidence',\n", + " 'deliver.p_yes'],\n", + " dtype='object')\n" + ] + } + ], "source": [ "# Transform to a Dataframe\n", "\n", @@ -118,9 +331,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total trades: 2775\n", + "Start date: 2024-03-01T00:00:01Z\n", + "End date: 2024-09-16T23:59:59Z\n", + "Filtered by date: 2775\n", + "Filtered by state: 2721\n", + "\n", + "Total outstanding mech requests: 13794\n", + "Filtered by date: 13794\n", + "\n", + "Summary of period 2024-03-01T00:00:01Z - 2024-09-16T23:59:59Z\n", + "-------------------------------------------------------------\n", + "Total trades: 2721\n", + "counts:\n", + "result\n", + "Win 1370\n", + "Lose 1030\n", + "Invalid 321\n", + "Unknown 0\n", + "Name: count, dtype: int64\n", + "\n", + "collateralAmount:\n", + "result\n", + "Win 669.925229\n", + "Lose 420.143946\n", + "Invalid 115.394206\n", + "Unknown 0.000000\n", + "Name: collateralAmount, dtype: float64\n", + "investment= 1205.4633803753843\n", + "market_fees= 24.109267607507682\n", + "mech_fees= 27.21\n", + "outstanding_mech_fees= 137.94\n", + "win_earnings= 1118.4334728628808\n", + "invalid_earnings= 115.39420550288135\n", + "\n", + "roi=-0.1153598314688754\n" + ] + } + ], "source": [ "# Filter dataset\n", "\n", @@ -190,9 +445,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Market with the highest number of trades: 0xd86896e9c34582737dc6c910ada3b6df0a5f8301 (7 trades)\n" + ] + } + ], "source": [ "# Display count by state\n", "result_counts = df['result'].value_counts()\n", @@ -251,9 +554,68 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Market with max. outcomeTokensTraded \n", + "0xe7192c9e0c013b1a355b780959c30c399a5c6ff30x3c01b79bad670a37c8784bdf47b973b341064f100x2e1\n", + "14.75095504900555\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Market with max. collateralAmount \n", + "0xce500294704e1243b5cb69a258196c0b1c65a7530x3c01b79bad670a37c8784bdf47b973b341064f100x29f\n", + "10.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot histogram\n", "plt.figure(figsize=(10, 6))\n", @@ -297,9 +659,50 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "\n", "# Plot histogram of confidence (total)\n", @@ -335,9 +738,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "\n", "\n", From 87dd2de87353b33250bf99834dcb634fc51809c5 Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 13:24:44 +0200 Subject: [PATCH 03/10] chore: update notebook --- notebooks/roi_analysis.ipynb | 390 ++--------------------------------- 1 file changed, 17 insertions(+), 373 deletions(-) diff --git a/notebooks/roi_analysis.ipynb b/notebooks/roi_analysis.ipynb index 1ad092d..3b3f07b 100644 --- a/notebooks/roi_analysis.ipynb +++ b/notebooks/roi_analysis.ipynb @@ -7,8 +7,8 @@ "# Trader ROI analysis notebook\n", "\n", "## How to run this notebook\n", - "1. Clone locally trader quickstart repository https://github.com/valory-xyz/trader-quickstart (branch main)\n", - "2. Clone locally market creator repository https://github.com/valory-xyz/market-creator (branch feat/roi_analysis). The rest of the steps occur on the market creator repository.\n", + "1. Clone locally trader quickstart repository https://github.com/valory-xyz/trader-quickstart.\n", + "2. Clone locally market creator repository https://github.com/valory-xyz/market-creator. The rest of the steps occur on the market creator repository.\n", "3. Poetry install\n", " ```bash\n", " cd market-creator\n", @@ -41,7 +41,7 @@ " If you are collecting a lot of data, it might take a while to generate the dataset, and you might need to run the scripts multiple times, due to network errors.\n", " As a result of this step you should end with a file called `roi_analysis_dataset_.json`\n", "\n", - "7. Edit the cell of this notebook with the required data\n", + "7. Edit the cell of this notebook with the required data:\n", "\n", " ```python\n", " # Edit these parameters accordingly\n", @@ -120,75 +120,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "service_id=335\n", - "service_safe_address='0x3c01B79BaD670A37C8784bDf47b973b341064f10'\n", - "service_id=335\n", - "service_safe_address='0x3c01B79BaD670A37C8784bDf47b973b341064f10'\n", - "0x3c01b79bad670a37c8784bdf47b973b341064f10\n", - " Fetching requests...\n", - " 16569 requests found\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " Fetching delivers: 100%|██████████| 1/1 [00:03<00:00, 3.39s/it]\n", - " Finding duplicate delivers: 100%|██████████| 16569/16569 [00:00<00:00, 116791.96it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Duplicate deliver ids found: 0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " Processing duplicate delivers: 0it [00:00, ?it/s]\n", - " Finding duplicate delivers: 100%|██████████| 16569/16569 [00:00<00:00, 677019.97it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Duplicate deliver ids found: 0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " Fetching IPFS contents: 0it [00:00, ?it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time of execution: 0:00:29.735739\n", - "Populating mech requests...\n", - "Populating market states...\n", - "Finished generating datasets for service 335\n", - "\n", - "Finished reading dataset:\n", - " - 2775 trades\n", - " - 16569 mech requests\n", - " - 13794 outstanding mech requests\n" - ] - } - ], + "outputs": [], "source": [ "service_safe_address = get_service_safe(service_id)\n", "\n", @@ -209,98 +143,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idoutcomeTokensTradedfpmm.stateresultmechTooldeliver.confidencedeliver.p_yes
0x47feda1a124caec341d8f60e5d524c77a76545a10x3c01b79bad670a37c8784bdf47b973b341064f100x10.286803closedWinprediction-online-sme0.80.15
0x02b29b4025d4bc4a93a24304a5bebaa930cd53e10x3c01b79bad670a37c8784bdf47b973b341064f100x20.203868closedWinprediction-online-sme0.80.30
0x703667dcd2860823fdcdabe4ed0b337efc17ab100x3c01b79bad670a37c8784bdf47b973b341064f100x30.214452closedWinprediction-online-sme0.80.30
0x703667dcd2860823fdcdabe4ed0b337efc17ab100x3c01b79bad670a37c8784bdf47b973b341064f100x5d0.226488closedWinprediction-online-sme0.80.30
0x9a2e0a075256fd2f21dfe8bbf1af7fdcd45b70f10x3c01b79bad670a37c8784bdf47b973b341064f100x40.213473closedWinprediction-online-sme0.80.30
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index(['collateralAmount', 'collateralAmountUSD', 'collateralToken',\n", - " 'creationTimestamp', 'feeAmount', 'id', 'mechRequestId',\n", - " 'oldOutcomeTokenMarginalPrice', 'outcomeIndex',\n", - " 'outcomeTokenMarginalPrice', 'outcomeTokensTraded', 'result', 'title',\n", - " 'transactionHash', 'type', 'creator.id',\n", - " 'fpmm.answerFinalizedTimestamp', 'fpmm.arbitrationOccurred',\n", - " 'fpmm.condition.id', 'fpmm.currentAnswer', 'fpmm.id',\n", - " 'fpmm.isPendingArbitration', 'fpmm.openingTimestamp', 'fpmm.outcomes',\n", - " 'fpmm.state', 'fpmm.title', 'mechTool', 'deliver.confidence',\n", - " 'deliver.p_yes'],\n", - " dtype='object')\n" - ] - } - ], + "outputs": [], "source": [ "# Transform to a Dataframe\n", "\n", @@ -331,51 +176,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total trades: 2775\n", - "Start date: 2024-03-01T00:00:01Z\n", - "End date: 2024-09-16T23:59:59Z\n", - "Filtered by date: 2775\n", - "Filtered by state: 2721\n", - "\n", - "Total outstanding mech requests: 13794\n", - "Filtered by date: 13794\n", - "\n", - "Summary of period 2024-03-01T00:00:01Z - 2024-09-16T23:59:59Z\n", - "-------------------------------------------------------------\n", - "Total trades: 2721\n", - "counts:\n", - "result\n", - "Win 1370\n", - "Lose 1030\n", - "Invalid 321\n", - "Unknown 0\n", - "Name: count, dtype: int64\n", - "\n", - "collateralAmount:\n", - "result\n", - "Win 669.925229\n", - "Lose 420.143946\n", - "Invalid 115.394206\n", - "Unknown 0.000000\n", - "Name: collateralAmount, dtype: float64\n", - "investment= 1205.4633803753843\n", - "market_fees= 24.109267607507682\n", - "mech_fees= 27.21\n", - "outstanding_mech_fees= 137.94\n", - "win_earnings= 1118.4334728628808\n", - "invalid_earnings= 115.39420550288135\n", - "\n", - "roi=-0.1153598314688754\n" - ] - } - ], + "outputs": [], "source": [ "# Filter dataset\n", "\n", @@ -445,57 +248,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Market with the highest number of trades: 0xd86896e9c34582737dc6c910ada3b6df0a5f8301 (7 trades)\n" - ] - } - ], + "outputs": [], "source": [ "# Display count by state\n", "result_counts = df['result'].value_counts()\n", @@ -554,68 +309,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Market with max. outcomeTokensTraded \n", - "0xe7192c9e0c013b1a355b780959c30c399a5c6ff30x3c01b79bad670a37c8784bdf47b973b341064f100x2e1\n", - "14.75095504900555\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Market with max. collateralAmount \n", - "0xce500294704e1243b5cb69a258196c0b1c65a7530x3c01b79bad670a37c8784bdf47b973b341064f100x29f\n", - "10.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot histogram\n", "plt.figure(figsize=(10, 6))\n", @@ -659,50 +355,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "# Plot histogram of confidence (total)\n", @@ -738,20 +393,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "\n", From eeee99dc1582a9137ce87f68c4cacf5f8e589f1e Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 13:30:44 +0200 Subject: [PATCH 04/10] chore: update notebook --- notebooks/roi_analysis.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/notebooks/roi_analysis.ipynb b/notebooks/roi_analysis.ipynb index 3b3f07b..eaffbfe 100644 --- a/notebooks/roi_analysis.ipynb +++ b/notebooks/roi_analysis.ipynb @@ -35,7 +35,7 @@ "6. The first time you want to run an analysis for a service, it’s recommended that you create the dataset outside the notebook as follows:\n", " \n", " ```bash\n", - " python generate_roi_analysis_dataset.py 327\n", + " python generate_roi_analysis_dataset.py 219\n", " ```\n", "\n", " If you are collecting a lot of data, it might take a while to generate the dataset, and you might need to run the scripts multiple times, due to network errors.\n", @@ -45,7 +45,7 @@ "\n", " ```python\n", " # Edit these parameters accordingly\n", - " service_id = 335\n", + " service_id = 219\n", " start_date_str = \"2024-03-01T00:00:01Z\"\n", " end_date_str = \"2024-09-16T23:59:59Z\"\n", " ```\n", @@ -113,7 +113,7 @@ "outputs": [], "source": [ "# Edit these parameters accordingly\n", - "service_id = 335\n", + "service_id = 219\n", "start_date_str = \"2024-03-01T00:00:01Z\"\n", "end_date_str = \"2024-09-16T23:59:59Z\"" ] From 27f54e68f75912f7cc63b9b454a1968973f45ab0 Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 13:46:09 +0200 Subject: [PATCH 05/10] fix: linters --- notebooks/generate_roi_analysis_dataset.py | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/notebooks/generate_roi_analysis_dataset.py b/notebooks/generate_roi_analysis_dataset.py index 35577de..f96f497 100644 --- a/notebooks/generate_roi_analysis_dataset.py +++ b/notebooks/generate_roi_analysis_dataset.py @@ -36,13 +36,14 @@ from dotenv import dotenv_values from web3 import Web3 + SCRIPT_PATH = Path(__file__).resolve().parent DOTENV_PATH = Path(SCRIPT_PATH, ".env") env_file_vars = dotenv_values(DOTENV_PATH) trader_quickstart_path = env_file_vars.get("TRADER_QUICKSTART_PATH") -sys.path.insert(0, '../scripts') +sys.path.insert(0, "../scripts") sys.path.insert(0, os.path.expanduser(trader_quickstart_path)) sys.path.insert(0, os.path.expanduser(f"{trader_quickstart_path}/scripts")) @@ -50,6 +51,7 @@ from mech_request_utils import get_mech_requests from trades import INVALID_ANSWER, MarketState, TradeResult + RPC = env_file_vars.get("RPC") SERVICE_REGISTRY_ADDRESS = "0x9338b5153AE39BB89f50468E608eD9d764B755fD" DATASET_PREFIX = "roi_analysis_dataset_" @@ -173,9 +175,13 @@ def generate_dataset(service_id: int) -> (Dict[str, Any], Dict[str, Any], List[s mech_requests = get_mech_requests(service_safe_address, dataset_json) - fpmm_trades = trades._query_omen_xdai_subgraph(service_safe_address.lower())[ # pylint: disable=protected-access + fpmm_trades = trades._query_omen_xdai_subgraph( + service_safe_address.lower() + )[ # pylint: disable=protected-access "data" - ]["fpmmTrades"] + ][ + "fpmmTrades" + ] outstanding_mech_request_ids = _populate_mech_requests(fpmm_trades, mech_requests) _populate_market_states(fpmm_trades) From 7c327f5829443b758b706b9a7b6e299b47fbc33a Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 17:06:15 +0200 Subject: [PATCH 06/10] fix: linters --- notebooks/generate_roi_analysis_dataset.py | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/notebooks/generate_roi_analysis_dataset.py b/notebooks/generate_roi_analysis_dataset.py index f96f497..f307fd6 100644 --- a/notebooks/generate_roi_analysis_dataset.py +++ b/notebooks/generate_roi_analysis_dataset.py @@ -18,9 +18,7 @@ # # ------------------------------------------------------------------------------ -""" -Generates dataset for ROI analysis -""" +"""Generates dataset for trader analysis""" # pylint: disable=wrong-import-position @@ -122,13 +120,13 @@ def _populate_mech_requests( found = True if i != idx: print( - f"WARNING: '{trade['title']}' was not found at idx={idx}, used idx={i} instead." + f"WARNING: {trade['title']} was not found at idx={idx}, used idx={i} instead." ) break if not found: print( - f"ERROR: '{trade['title']}' is not found in any mech request up to {N} indices before idx={idx}." + f"ERROR: {trade['title']} is not found in any mech request up to {N} indices before idx={idx}." ) print(f"{trade['id']=}") @@ -175,13 +173,9 @@ def generate_dataset(service_id: int) -> (Dict[str, Any], Dict[str, Any], List[s mech_requests = get_mech_requests(service_safe_address, dataset_json) - fpmm_trades = trades._query_omen_xdai_subgraph( + fpmm_trades = trades._query_omen_xdai_subgraph( # pylint: disable=protected-access service_safe_address.lower() - )[ # pylint: disable=protected-access - "data" - ][ - "fpmmTrades" - ] + )["data"]["fpmmTrades"] outstanding_mech_request_ids = _populate_mech_requests(fpmm_trades, mech_requests) _populate_market_states(fpmm_trades) From 060e56843ce7acd05b735a7567a80617054398f3 Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 17:12:49 +0200 Subject: [PATCH 07/10] fix: linters --- notebooks/generate_roi_analysis_dataset.py | 1 + 1 file changed, 1 insertion(+) diff --git a/notebooks/generate_roi_analysis_dataset.py b/notebooks/generate_roi_analysis_dataset.py index f307fd6..e9d859a 100644 --- a/notebooks/generate_roi_analysis_dataset.py +++ b/notebooks/generate_roi_analysis_dataset.py @@ -21,6 +21,7 @@ """Generates dataset for trader analysis""" # pylint: disable=wrong-import-position +# noqa: E402 import argparse import bisect From ba039dd3261597d7a81ff97fe2e36913e542476a Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 17:17:51 +0200 Subject: [PATCH 08/10] fix: linters --- notebooks/generate_roi_analysis_dataset.py | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/notebooks/generate_roi_analysis_dataset.py b/notebooks/generate_roi_analysis_dataset.py index e9d859a..08fd886 100644 --- a/notebooks/generate_roi_analysis_dataset.py +++ b/notebooks/generate_roi_analysis_dataset.py @@ -20,7 +20,7 @@ """Generates dataset for trader analysis""" -# pylint: disable=wrong-import-position +# pylint: disable=wrong-import-position,protected-access # noqa: E402 import argparse @@ -110,7 +110,14 @@ def _populate_mech_requests( print("ERROR: idx < 0") continue - N = 3 # Adjust N to the number of indices you want to check + # Almost always, the corresponding mech request should be the mech + # request immediately before the trade 'creationTimestamp', which is + # at position 'idx'. Under some exceptional circumstances, it might + # be a few positions before (e.g., if the trader was crashed and + # the mech responded 2 requests on the same block). For this reason, + # this part of the code searches up to N mech requests before the + # expected one. + N = 3 for i in range(idx, max(0, idx - N), -1): mech_request = sorted_mech_requests[i] mech_request_id = mech_request["id"] @@ -139,7 +146,7 @@ def _populate_market_states(fpmm_trades: Dict[str, Any]) -> None: for trade in fpmm_trades: fpmm = trade["fpmm"] - state = trades._get_market_state(fpmm) # pylint: disable=protected-access + state = trades._get_market_state(fpmm) fpmm["state"] = state.value if state == MarketState.CLOSED: @@ -174,9 +181,9 @@ def generate_dataset(service_id: int) -> (Dict[str, Any], Dict[str, Any], List[s mech_requests = get_mech_requests(service_safe_address, dataset_json) - fpmm_trades = trades._query_omen_xdai_subgraph( # pylint: disable=protected-access - service_safe_address.lower() - )["data"]["fpmmTrades"] + fpmm_trades = trades._query_omen_xdai_subgraph(service_safe_address.lower())[ + "data" + ]["fpmmTrades"] outstanding_mech_request_ids = _populate_mech_requests(fpmm_trades, mech_requests) _populate_market_states(fpmm_trades) From 383798592eda66f79e1cd8956b2ed2a55fd3dfc6 Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 17:29:36 +0200 Subject: [PATCH 09/10] chore: rename file --- ..._analysis_dataset.py => generate_trader_dataset.py} | 2 +- notebooks/roi_analysis.ipynb | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) rename notebooks/{generate_roi_analysis_dataset.py => generate_trader_dataset.py} (99%) diff --git a/notebooks/generate_roi_analysis_dataset.py b/notebooks/generate_trader_dataset.py similarity index 99% rename from notebooks/generate_roi_analysis_dataset.py rename to notebooks/generate_trader_dataset.py index 08fd886..2809dc5 100644 --- a/notebooks/generate_roi_analysis_dataset.py +++ b/notebooks/generate_trader_dataset.py @@ -53,7 +53,7 @@ RPC = env_file_vars.get("RPC") SERVICE_REGISTRY_ADDRESS = "0x9338b5153AE39BB89f50468E608eD9d764B755fD" -DATASET_PREFIX = "roi_analysis_dataset_" +DATASET_PREFIX = "trader_dataset_" def _get_contract(address: str) -> Any: diff --git a/notebooks/roi_analysis.ipynb b/notebooks/roi_analysis.ipynb index eaffbfe..13f1793 100644 --- a/notebooks/roi_analysis.ipynb +++ b/notebooks/roi_analysis.ipynb @@ -35,11 +35,11 @@ "6. The first time you want to run an analysis for a service, it’s recommended that you create the dataset outside the notebook as follows:\n", " \n", " ```bash\n", - " python generate_roi_analysis_dataset.py 219\n", + " python generate_trader_dataset.py 219\n", " ```\n", "\n", " If you are collecting a lot of data, it might take a while to generate the dataset, and you might need to run the scripts multiple times, due to network errors.\n", - " As a result of this step you should end with a file called `roi_analysis_dataset_.json`\n", + " As a result of this step you should end with a file called `trader_dataset_.json`\n", "\n", "7. Edit the cell of this notebook with the required data:\n", "\n", @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ "sys.path.insert(0, os.path.expanduser(trader_quickstart_path))\n", "sys.path.insert(0, os.path.expanduser(f\"{trader_quickstart_path}/scripts\"))\n", "\n", - "from generate_roi_analysis_dataset import get_service_safe, generate_dataset, DATASET_PREFIX\n", + "from generate_trader_dataset import get_service_safe, generate_dataset, DATASET_PREFIX\n", "from trades import MarketState, TradeResult, INVALID_ANSWER, _compute_roi\n", "\n", "def annotate_bars(ax):\n", @@ -108,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ From 55066ac98c8fd4ed959a20e1fb097ef6c9ac3170 Mon Sep 17 00:00:00 2001 From: jmoreira-valory Date: Tue, 17 Sep 2024 17:36:23 +0200 Subject: [PATCH 10/10] fix: linters --- notebooks/generate_trader_dataset.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/notebooks/generate_trader_dataset.py b/notebooks/generate_trader_dataset.py index 2809dc5..c810444 100644 --- a/notebooks/generate_trader_dataset.py +++ b/notebooks/generate_trader_dataset.py @@ -21,7 +21,6 @@ """Generates dataset for trader analysis""" # pylint: disable=wrong-import-position,protected-access -# noqa: E402 import argparse import bisect @@ -46,9 +45,9 @@ sys.path.insert(0, os.path.expanduser(trader_quickstart_path)) sys.path.insert(0, os.path.expanduser(f"{trader_quickstart_path}/scripts")) -import trades -from mech_request_utils import get_mech_requests -from trades import INVALID_ANSWER, MarketState, TradeResult +import trades # noqa: E402 +from mech_request_utils import get_mech_requests # noqa: E402 +from trades import INVALID_ANSWER, MarketState, TradeResult # noqa: E402 RPC = env_file_vars.get("RPC")