Eur usd stableswap

.github/workflows/python-app.yml

@@ -16,10 +16,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
-    - name: Set up Python 3.10
+    - name: Set up Python 3.13.5
       uses: actions/setup-python@v5
       with:
-        python-version: "3.10"
+        python-version: "3.13.5"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip

.gitignore

@@ -16,3 +16,11 @@
 *.env
 /hydradx/apps/fees/data
 /hydradx/apps/money_market/archive
+/hydradx/apps/fees/acct_swaps_5_0x7279fcf9694718e1234d102825dccaf332f0ea36edf1ca7c0358c4b68260d24b.json
+/hydradx/apps/omnipool/cached data/all_trades.txt
+/hydradx/other tests/cached data/all_trades.txt
+/hydradx/apps/omnipool/cached data/lrna_sells.txt
+/hydradx/other tests/cached data/lrna_sells.txt
+/hydradx/tests/money_market_save_test.json
+**/cached\ data/**
+/.streamlit/secrets.toml

README.md

@@ -3,7 +3,7 @@
 The main HydraDX model can be found in "hydradx".
 
 Installation: 
-* Install Python 3.9. Not 3.8, it doesn't support all the features used in this code. Not 3.10, there is a compatibility issue with one of the libraries that you don't want to deal with. Link: https://www.python.org/downloads/release/python-3912/
+* Install Python 3.10 or higher
 * Clone the repository and navigate to the root folder, HydraDx-simulations
 * In terminal, enter 'pip install -r requirements.txt'
 * Alternatively, open the project folder in PyCharm, and you'll be prompted to create a virtual environment for this project. 

hydradx/apps/everything_is_collateral/other_tests.py

@@ -12,7 +12,7 @@
 from hydradx.model.amm.omnipool_amm import OmnipoolState
 from hydradx.model.amm.agents import Agent
 from hydradx.model.plot_utils import color_gradient
-from hydradx.model.indexer_utils import get_current_omnipool, get_omnipool_trades, get_current_omnipool_assets, \
+from hydradx.model.indexer_utils import get_current_omnipool, get_omnipool_trades, get_current_omnipool_asset_ids, \
     get_asset_info_by_ids
 
 st.markdown("""

hydradx/apps/fees/slip_fees_chart.py

@@ -0,0 +1,82 @@
+import random
+
+from IPython.core.pylabtools import figsize
+from matplotlib import pyplot as plt
+import sys, os
+import streamlit as st
+import copy
+
+from matplotlib.lines import lineStyles
+from streamlit import session_state
+
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../"))
+sys.path.append(project_root)
+
+from hydradx.model import production_settings
+from hydradx.model.indexer_utils import get_current_omnipool_router
+
+st.markdown("""
+    <style>
+        .stNumberInput button {
+            display: none;
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+@st.cache_data(show_spinner=True)
+def load_omnipool_router():
+    router = get_current_omnipool_router()
+    return router
+
+def run_app():
+    st.session_state.router = load_omnipool_router()
+    st.session_state.omnipool = st.session_state.router.exchanges['omnipool']
+    omnipool = st.session_state.omnipool
+    omnipool.asset_fee = 0
+    omnipool.lrna_fee = 0
+    omnipool.max_lrna_fee = 1
+    omnipool.max_asset_fee = 1
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.session_state.tkn_buy = st.selectbox("Select token to buy:", options=omnipool.asset_list, index=omnipool.asset_list.index('HDX'))
+    with col2:
+        st.session_state.tkn_sell = st.selectbox("Select token to sell:", options=omnipool.asset_list, index=omnipool.asset_list.index('DOT'))
+    with col3:
+        omnipool.slip_factor = st.number_input("Slip factor:", min_value=0.0, max_value=10.0, value=1.0)
+    plot_trade_sizes(st.session_state.tkn_buy, st.session_state.tkn_sell, st.session_state.router, st.session_state.omnipool)
+
+def plot_trade_sizes(tkn_buy, tkn_sell, router, omnipool):
+    trade_sizes = [10 ** (i / 5) for i in range(0, 26)]
+    fees = []
+    for trade_size in trade_sizes:
+        sell_quantity = trade_size * router.price('Tether', tkn_sell)
+        outputs = omnipool.calculate_out_given_in(tkn_buy=tkn_buy, tkn_sell=tkn_sell, sell_quantity=sell_quantity)
+        buy_quantity, delta_qi, delta_qj, asset_fee_total, lrna_fee_total, slip_fee_buy, slip_fee_sell = outputs
+        slip_fee_total = slip_fee_buy + slip_fee_sell
+        slip_fee_percent = slip_fee_total / -delta_qi
+        print(f"${trade_size:.2f} worth of {tkn_sell} sold for {tkn_buy} = {slip_fee_percent * 100:.4f}% slip fee")
+        fees.append(slip_fee_percent)
+
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.plot(trade_sizes, [fee * 100 for fee in fees], label='Slip Fee %', color='orange')
+    ax.set_xscale('log')
+    ax.set_yscale('log')
+    ax.set_xlabel(f'Value of {tkn_sell} sold for {tkn_buy} (USD)')
+    ax.set_xticks([1, 10, 100, 1000, 10000, 100000], ['$1', '$10', '$100', '$1000', '$10k', '$100k'])
+    ax.set_ylabel('Slip Fee (%)')
+    ax.set_yticks(
+        [0.0001, 0.001, 0.01, 0.1, 1] + ([10] if max(fees) * 100 > 1 else []),
+        ['0.0001%', '0.001%', '0.01%', '0.1%', '1%'] + (['10%'] if max(fees) * 100 > 1 else [])
+    )
+    # label the slip fee values at each dollar-value tick
+    for i, trade_size in enumerate(trade_sizes):
+        if trade_size in [1, 10, 100, 1000, 10000, 100000]:
+            ax.text(trade_size, fees[i] * 100, f"{fees[i] * 100:.4f}%", fontsize=8, ha='center', va='bottom')
+    ax.set_title('Total Slip Fee')
+    ax.grid(True, which="both", ls="--", linewidth=0.5, color="gray")
+    ax.legend()
+    st.pyplot(fig)
+
+st.set_page_config(layout="wide")
+st.title("Omnipool Slip Fees Chart")
+run_app()

hydradx/apps/omnipool/assets_liquidity_graph.py

@@ -0,0 +1,123 @@
+from hydradx.model.indexer_utils import query_indexer, get_blocks_at_timestamps, get_asset_info_by_ids
+import datetime
+from matplotlib import pyplot as plt
+from pathlib import Path
+import streamlit as st
+import json
+import math
+
+LIQUIDITY_GRAPH_TARGET_POINTS = 1000
+
+
+def _sort_key(value):
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return value
+
+
+def compress_liquidity_series(liquidity_series: dict, target_points: int) -> dict:
+    if target_points <= 0:
+        raise ValueError("target_points must be > 0")
+    if len(liquidity_series) <= target_points:
+        return dict(liquidity_series)
+
+    items = sorted(liquidity_series.items(), key=lambda item: _sort_key(item[0]))
+    total = len(items)
+    batch_size = max(1, math.ceil(total / target_points))
+    compressed = {}
+
+    for idx in range(0, total, batch_size):
+        batch = items[idx: idx + batch_size]
+        first_key = batch[0][0]
+        avg_value = sum(value for _, value in batch) / len(batch)
+        compressed[first_key] = avg_value
+
+    last_key, last_value = items[-1]
+    compressed[last_key] = last_value
+    return compressed
+
+
+def _to_int_keyed(series: dict) -> dict:
+    return {int(k): v for k, v in series.items()}
+
+
+def get_liquidity_over_time():
+    dates = [
+                datetime.datetime(2025, 11, day=i + 1) for i in range(30)
+            ] + [
+                datetime.datetime(year=2025, month=12, day=i + 1) for i in range(31)
+            ]
+    block_map = get_blocks_at_timestamps(dates)
+    ordered_blocks = sorted(block_map.items(), key=lambda item: item[0])
+    ordered_dates = [item[0] for item in ordered_blocks]
+    block_numbers = [item[1] for item in ordered_blocks]
+    liquidity = {}
+
+    if not Path.exists(Path(__file__).parent / 'cached data' / 'liquidity.json'):
+        for i, start_block in enumerate(block_numbers[:-1]):
+            date = dates[i]
+            print(f"scanning {date}")
+            blocks_per_query = 1000
+            end_block = block_numbers[1 + 1]
+            for block in range(start_block, end_block, blocks_per_query):
+                query_start = block
+                query_end = min(block + blocks_per_query, end_block)
+                query = f"""
+                    query AssetBalancesByBlockHeight {{
+                        omnipoolAssetHistoricalData(
+                            filter: {{paraBlockHeight: {{greaterThanOrEqualTo: {query_start}, lessThan: {query_end}}}}}
+                        ) {{
+                            nodes
+                            {{
+                                freeBalance
+                                assetId
+                                paraBlockHeight
+                            }}
+                        }}
+                    }}
+                """
+
+                results = query_indexer("https://galacticcouncil.squids.live/hydration-pools:unified-prod/api/graphql", query)
+                for result in results["data"]["omnipoolAssetHistoricalData"]["nodes"]:
+                    asset_id = result["assetId"]
+                    free_balance = int(result["freeBalance"])
+                    result_block = int(result["paraBlockHeight"])
+                    if asset_id not in liquidity:
+                        liquidity[asset_id] = {}
+                    liquidity[asset_id][result_block] = free_balance
+
+        with open (Path(__file__).parent / 'cached data' / 'liquidity.json', 'w') as f:
+            json.dump(liquidity, f)
+    else:
+        with open (Path(__file__).parent / 'cached data' / 'liquidity.json', 'r') as f:
+            liquidity = json.load(f)
+
+    asset_names = {tkn.id: tkn.unique_id for tkn in get_asset_info_by_ids(list(liquidity.keys())).values()}
+    graph_liquidity = {}
+    for tkn in liquidity:
+        raw_series = _to_int_keyed(liquidity[tkn])
+        if len(raw_series) > LIQUIDITY_GRAPH_TARGET_POINTS:
+            graph_liquidity[tkn] = compress_liquidity_series(
+                raw_series,
+                target_points=LIQUIDITY_GRAPH_TARGET_POINTS,
+            )
+        else:
+            graph_liquidity[tkn] = dict(raw_series)
+        graph_liquidity[tkn][block_numbers[0]] = list(raw_series.values())[0]
+        graph_liquidity[tkn][block_numbers[-1]] = list(raw_series.values())[-1]
+        sorted_items = sorted(graph_liquidity[tkn].items(), key=lambda item: _sort_key(item[0]))
+        fig, ax = plt.subplots(figsize=(12, 4))
+        ax.plot([item[0] for item in sorted_items], [item[1] for item in sorted_items])
+        ax.set_title(f"Liquidity of {asset_names[tkn]} in Omnipool")
+        ax.set_xlabel("Date")
+        ax.set_ylabel("Free Balance")
+        ax.set_xticks(block_numbers)
+        ax.set_xticklabels([date.strftime('%Y-%m-%d') for date in ordered_dates])
+        ax.tick_params(axis="x", labelsize=8)
+
+        plt.tight_layout()
+        plt.show()
+        st.pyplot(fig)
+    pass
+