horatio-data-provider 0.1.0__tar.gz

horatio_data_provider-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.env
+.venv/
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+data/*.duckdb*
+*.parquet

horatio_data_provider-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: horatio-data-provider
+Version: 0.1.0
+Summary: Python client for the Horatio data provider service
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.25
+Requires-Dist: pandas>=2.0
+Requires-Dist: pyarrow>=14.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'

horatio_data_provider-0.1.0/horatio_data_provider/__init__.py

@@ -0,0 +1,4 @@
+from ._client import DataProviderClient
+from .exceptions import DataProviderError, DataProviderHTTPError
+
+__all__ = ["DataProviderClient", "DataProviderError", "DataProviderHTTPError"]

horatio_data_provider-0.1.0/horatio_data_provider/_client.py

@@ -0,0 +1,42 @@
+import httpx
+
+from .erc20 import ERC20Namespace
+from .binance import BinanceNamespace
+from .protocols import (
+    AaveNamespace,
+    UniswapNamespace,
+    LidoNamespace,
+    StaderNamespace,
+    ThresholdNamespace,
+    NativeNamespace,
+    CacheNamespace,
+)
+
+
+class DataProviderClient:
+    def __init__(self, url: str):
+        self._url = url.rstrip("/")
+        self._session = httpx.AsyncClient(timeout=3600)
+        self.erc20 = ERC20Namespace(self._session, self._url)
+        self.binance = BinanceNamespace(self._session, self._url)
+        self.aave = AaveNamespace(self._session, self._url)
+        self.uniswap = UniswapNamespace(self._session, self._url)
+        self.lido = LidoNamespace(self._session, self._url)
+        self.stader = StaderNamespace(self._session, self._url)
+        self.threshold = ThresholdNamespace(self._session, self._url)
+        self.native = NativeNamespace(self._session, self._url)
+        self.cache = CacheNamespace(self._session, self._url)
+
+    async def health(self) -> bool:
+        response = await self._session.get(self._url + "/health")
+        response.raise_for_status()
+        return True
+
+    async def close(self) -> None:
+        await self._session.aclose()
+
+    async def __aenter__(self) -> "DataProviderClient":
+        return self
+
+    async def __aexit__(self, *_) -> None:
+        await self.close()

horatio_data_provider-0.1.0/horatio_data_provider/_http.py

@@ -0,0 +1,17 @@
+import io
+
+import httpx
+import pandas as pd
+import pyarrow.parquet as pq
+
+from .exceptions import DataProviderHTTPError
+
+
+async def fetch_parquet(session: httpx.AsyncClient, url: str, body: dict) -> pd.DataFrame:
+    response = await session.post(url, json=body)
+    content_type = response.headers.get("content-type", "")
+    if "application/json" in content_type:
+        data = response.json()
+        raise DataProviderHTTPError(response.status_code, data.get("error", str(data)))
+    response.raise_for_status()
+    return pq.read_table(io.BytesIO(response.content)).to_pandas()

horatio_data_provider-0.1.0/horatio_data_provider/_query.py

@@ -0,0 +1,36 @@
+import httpx
+import pandas as pd
+
+from ._http import fetch_parquet
+
+
+class BaseQuery:
+    def __init__(self, session: httpx.AsyncClient, base_url: str, body: dict):
+        self._session = session
+        self._base_url = base_url
+        self._body = body
+
+    def network(self, n: str) -> "BaseQuery":
+        self._body["network"] = n
+        return self
+
+    def time_range(self, since: str, until: str) -> "BaseQuery":
+        self._body["since"] = since
+        self._body["until"] = until
+        return self
+
+
+class CacheableQuery(BaseQuery):
+    def cache(self, cache_type: str = "append") -> "CacheableQuery":
+        self._body["cache"] = True
+        self._body["cache_type"] = cache_type
+        return self
+
+
+class EventQuery(BaseQuery):
+    def __init__(self, session: httpx.AsyncClient, base_url: str, path: str, body: dict):
+        super().__init__(session, base_url, body)
+        self._path = path
+
+    async def fetch(self) -> pd.DataFrame:
+        return await fetch_parquet(self._session, self._base_url + self._path, self._body)

horatio_data_provider-0.1.0/horatio_data_provider/binance.py

@@ -0,0 +1,39 @@
+import httpx
+import pandas as pd
+
+from ._http import fetch_parquet
+from ._query import BaseQuery, CacheableQuery
+
+
+class RawTradesQuery(CacheableQuery):
+    def __init__(self, session: httpx.AsyncClient, base_url: str, token: str):
+        super().__init__(session, base_url, {"token": token})
+
+    async def fetch(self) -> pd.DataFrame:
+        return await fetch_parquet(self._session, self._base_url + "/binance/raw_trades/read", self._body)
+
+
+class OHLCVQuery(BaseQuery):
+    def __init__(self, session: httpx.AsyncClient, base_url: str, token: str, window: str):
+        super().__init__(session, base_url, {"token": token, "window": window})
+
+    async def fetch(self) -> pd.DataFrame:
+        return await fetch_parquet(self._session, self._base_url + "/binance/ohlcv/read", self._body)
+
+
+class BinanceNamespace:
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def raw_trades(self, token: str) -> RawTradesQuery:
+        return RawTradesQuery(self._session, self._base_url, token)
+
+    def ohlcv(self, token: str, window: str) -> OHLCVQuery:
+        return OHLCVQuery(self._session, self._base_url, token, window)
+
+    async def flush_raw_trades(self, token: str | None = None) -> None:
+        body = {}
+        if token is not None:
+            body["token"] = token
+        await self._session.post(self._base_url + "/binance/raw_trades/flush", json=body)

horatio_data_provider-0.1.0/horatio_data_provider/erc20.py

@@ -0,0 +1,40 @@
+import httpx
+import pandas as pd
+
+from ._http import fetch_parquet
+from ._query import CacheableQuery
+
+
+class ERC20TransfersQuery(CacheableQuery):
+    def __init__(self, session: httpx.AsyncClient, base_url: str, tokens: list[str]):
+        super().__init__(session, base_url, {"tokens": tokens})
+        self._min_amount = None
+
+    def min_amount(self, amount: float) -> "ERC20TransfersQuery":
+        self._min_amount = amount
+        return self
+
+    async def fetch(self) -> pd.DataFrame:
+        if self._min_amount is not None:
+            self._body["min_amount"] = self._min_amount
+            path = "/erc20_transfers/read/min"
+        else:
+            path = "/erc20_transfers/read"
+        return await fetch_parquet(self._session, self._base_url + path, self._body)
+
+
+class ERC20Namespace:
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def transfers(self, tokens: list[str]) -> ERC20TransfersQuery:
+        return ERC20TransfersQuery(self._session, self._base_url, tokens)
+
+    async def flush(self, network: str | None = None, token: str | None = None) -> None:
+        body = {}
+        if network is not None:
+            body["network"] = network
+        if token is not None:
+            body["token"] = token
+        await self._session.post(self._base_url + "/erc20_transfers/flush", json=body)

horatio_data_provider-0.1.0/horatio_data_provider/exceptions.py

@@ -0,0 +1,8 @@
+class DataProviderError(Exception):
+    pass
+
+
+class DataProviderHTTPError(DataProviderError):
+    def __init__(self, status_code: int, message: str):
+        self.status_code = status_code
+        super().__init__(f"HTTP {status_code}: {message}")

horatio_data_provider-0.1.0/horatio_data_provider/protocols.py

@@ -0,0 +1,151 @@
+import httpx
+import pandas as pd
+
+from ._http import fetch_parquet
+from ._query import BaseQuery, EventQuery
+
+
+class AaveNamespace:
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def _q(self, event: str) -> EventQuery:
+        return EventQuery(self._session, self._base_url, "/aave/read", {"event": event})
+
+    def deposits(self) -> EventQuery:
+        return self._q("deposit")
+
+    def withdrawals(self) -> EventQuery:
+        return self._q("withdraw")
+
+    def borrows(self) -> EventQuery:
+        return self._q("borrow")
+
+    def repays(self) -> EventQuery:
+        return self._q("repay")
+
+    def flashloans(self) -> EventQuery:
+        return self._q("flashloan")
+
+    def liquidations(self) -> EventQuery:
+        return self._q("liquidation")
+
+
+class UniswapNamespace:
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def _q(self, event: str, symbol0: str, symbol1: str, fee: int) -> EventQuery:
+        return EventQuery(
+            self._session,
+            self._base_url,
+            "/uniswap/read",
+            {"event": event, "symbol0": symbol0, "symbol1": symbol1, "fee": fee},
+        )
+
+    def swaps(self, symbol0: str, symbol1: str, fee: int) -> EventQuery:
+        return self._q("swap", symbol0, symbol1, fee)
+
+    def deposits(self, symbol0: str, symbol1: str, fee: int) -> EventQuery:
+        return self._q("deposit", symbol0, symbol1, fee)
+
+    def withdrawals(self, symbol0: str, symbol1: str, fee: int) -> EventQuery:
+        return self._q("withdraw", symbol0, symbol1, fee)
+
+    def collects(self, symbol0: str, symbol1: str, fee: int) -> EventQuery:
+        return self._q("collect", symbol0, symbol1, fee)
+
+
+class LidoNamespace:
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def _q(self, event: str) -> EventQuery:
+        return EventQuery(self._session, self._base_url, "/lido/read", {"event": event})
+
+    def deposits(self) -> EventQuery:
+        return self._q("deposit")
+
+    def withdrawal_requests(self) -> EventQuery:
+        return self._q("withdrawal_request")
+
+    def withdrawals_claimed(self) -> EventQuery:
+        return self._q("withdrawal_claimed")
+
+
+class StaderNamespace:
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def _q(self, event: str) -> EventQuery:
+        return EventQuery(self._session, self._base_url, "/stader/read", {"event": event})
+
+    def deposits(self) -> EventQuery:
+        return self._q("deposit")
+
+    def withdrawal_requests(self) -> EventQuery:
+        return self._q("withdrawal_request")
+
+    def withdrawals(self) -> EventQuery:
+        return self._q("withdrawal")
+
+
+class ThresholdNamespace:
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def _q(self, event: str) -> EventQuery:
+        return EventQuery(self._session, self._base_url, "/threshold/read", {"event": event})
+
+    def deposits(self) -> EventQuery:
+        return self._q("deposit")
+
+    def deposit_requests(self) -> EventQuery:
+        return self._q("deposit_request")
+
+    def withdrawals(self) -> EventQuery:
+        return self._q("withdrawal")
+
+    def withdrawal_requests(self) -> EventQuery:
+        return self._q("withdrawal_request")
+
+
+class NativeTransfersQuery(BaseQuery):
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        super().__init__(session, base_url, {})
+        self._min_amount = None
+
+    def min_amount(self, amount: float) -> "NativeTransfersQuery":
+        self._min_amount = amount
+        return self
+
+    async def fetch(self) -> pd.DataFrame:
+        if self._min_amount is not None:
+            self._body["min_amount"] = self._min_amount
+            path = "/native_transfers/read/min"
+        else:
+            path = "/native_transfers/read"
+        return await fetch_parquet(self._session, self._base_url + path, self._body)
+
+
+class NativeNamespace:
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def transfers(self) -> NativeTransfersQuery:
+        return NativeTransfersQuery(self._session, self._base_url)
+
+
+class CacheNamespace:
+    def __init__(self, session: httpx.AsyncClient, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    async def flush(self) -> None:
+        await self._session.post(self._base_url + "/cache/flush", json={})

horatio_data_provider-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "horatio-data-provider"
+version = "0.1.0"
+description = "Python client for the Horatio data provider service"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.25",
+    "pyarrow>=14.0",
+    "pandas>=2.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23", "respx>=0.21"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

horatio_data_provider-0.1.0/tests/conftest.py

@@ -0,0 +1,23 @@
+import io
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pytest
+
+
+def make_parquet_bytes(df: pd.DataFrame) -> bytes:
+    table = pa.Table.from_pandas(df)
+    buf = io.BytesIO()
+    pq.write_table(table, buf)
+    return buf.getvalue()
+
+
+@pytest.fixture
+def sample_df():
+    return pd.DataFrame({"amount": [1.0, 2.0], "token": ["USDT", "USDC"]})
+
+
+@pytest.fixture
+def parquet_bytes(sample_df):
+    return make_parquet_bytes(sample_df)

horatio_data_provider-0.1.0/tests/test_binance.py

@@ -0,0 +1,66 @@
+import json
+
+import httpx
+import pytest
+import respx
+
+from horatio_data_provider import DataProviderClient
+
+BASE = "http://test"
+
+
+@pytest.fixture
+def client():
+    return DataProviderClient(BASE)
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_raw_trades_url_and_body(client, parquet_bytes):
+    route = respx.post(f"{BASE}/binance/raw_trades/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.binance.raw_trades("BTC").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["token"] == "BTC"
+    assert body["since"] == "2025-01-01"
+    assert body["until"] == "2025-01-02"
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_ohlcv_url_and_window(client, parquet_bytes):
+    route = respx.post(f"{BASE}/binance/ohlcv/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.binance.ohlcv("BTC", "1h").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["token"] == "BTC"
+    assert body["window"] == "1h"
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_raw_trades_cache(client, parquet_bytes):
+    route = respx.post(f"{BASE}/binance/raw_trades/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.binance.raw_trades("BTC").time_range("2025-01-01", "2025-01-02").cache("force_replace").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["cache"] is True
+    assert body["cache_type"] == "force_replace"
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_flush_raw_trades(client):
+    route = respx.post(f"{BASE}/binance/raw_trades/flush").mock(
+        return_value=httpx.Response(200, content=b"{}", headers={"content-type": "application/json"})
+    )
+    await client.binance.flush_raw_trades(token="BTC")
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["token"] == "BTC"

horatio_data_provider-0.1.0/tests/test_erc20.py

@@ -0,0 +1,86 @@
+import json
+
+import httpx
+import pytest
+import respx
+
+from horatio_data_provider import DataProviderClient, DataProviderHTTPError
+from .conftest import make_parquet_bytes
+import pandas as pd
+
+BASE = "http://test"
+
+
+@pytest.fixture
+def client():
+    return DataProviderClient(BASE)
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_transfers_correct_url_and_body(client, parquet_bytes):
+    route = respx.post(f"{BASE}/erc20_transfers/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    df = await client.erc20.transfers(["USDT", "USDC"]).network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["tokens"] == ["USDT", "USDC"]
+    assert body["network"] == "ETH"
+    assert body["since"] == "2025-01-01"
+    assert body["until"] == "2025-01-02"
+    assert isinstance(df, pd.DataFrame)
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_min_amount_routes_to_min_endpoint(client, parquet_bytes):
+    route = respx.post(f"{BASE}/erc20_transfers/read/min").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.erc20.transfers(["USDT"]).network("ETH").time_range("2025-01-01", "2025-01-02").min_amount(1000).fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["min_amount"] == 1000
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_cache_sets_body_fields(client, parquet_bytes):
+    route = respx.post(f"{BASE}/erc20_transfers/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.erc20.transfers(["USDT"]).network("ETH").time_range("2025-01-01", "2025-01-02").cache("append").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["cache"] is True
+    assert body["cache_type"] == "append"
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_flush(client):
+    route = respx.post(f"{BASE}/erc20_transfers/flush").mock(
+        return_value=httpx.Response(200, content=b"{}", headers={"content-type": "application/json"})
+    )
+    await client.erc20.flush(network="ETH", token="USDT")
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["network"] == "ETH"
+    assert body["token"] == "USDT"
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_http_error_propagation(client):
+    respx.post(f"{BASE}/erc20_transfers/read").mock(
+        return_value=httpx.Response(
+            400,
+            json={"error": "bad request"},
+            headers={"content-type": "application/json"},
+        )
+    )
+    with pytest.raises(DataProviderHTTPError) as exc_info:
+        await client.erc20.transfers(["USDT"]).network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert exc_info.value.status_code == 400
+    assert "bad request" in str(exc_info.value)

horatio_data_provider-0.1.0/tests/test_protocols.py

@@ -0,0 +1,147 @@
+import json
+
+import httpx
+import pytest
+import respx
+
+from horatio_data_provider import DataProviderClient
+
+BASE = "http://test"
+
+
+@pytest.fixture
+def client():
+    return DataProviderClient(BASE)
+
+
+# --- AAVE ---
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_aave_deposit_event_routing(client, parquet_bytes):
+    route = respx.post(f"{BASE}/aave/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.aave.deposits().network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["event"] == "deposit"
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_aave_borrow_event_routing(client, parquet_bytes):
+    route = respx.post(f"{BASE}/aave/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.aave.borrows().network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["event"] == "borrow"
+
+
+# --- Uniswap ---
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_uniswap_swaps_body(client, parquet_bytes):
+    route = respx.post(f"{BASE}/uniswap/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.uniswap.swaps("WETH", "USDC", fee=500).network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["event"] == "swap"
+    assert body["symbol0"] == "WETH"
+    assert body["symbol1"] == "USDC"
+    assert body["fee"] == 500
+
+
+# --- Lido ---
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_lido_deposit_event_routing(client, parquet_bytes):
+    route = respx.post(f"{BASE}/lido/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.lido.deposits().network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["event"] == "deposit"
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_lido_withdrawal_request_event_routing(client, parquet_bytes):
+    route = respx.post(f"{BASE}/lido/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.lido.withdrawal_requests().network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["event"] == "withdrawal_request"
+
+
+# --- Stader ---
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_stader_deposit_event_routing(client, parquet_bytes):
+    route = respx.post(f"{BASE}/stader/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.stader.deposits().network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["event"] == "deposit"
+
+
+# --- Threshold ---
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_threshold_deposit_request_event_routing(client, parquet_bytes):
+    route = respx.post(f"{BASE}/threshold/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.threshold.deposit_requests().network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["event"] == "deposit_request"
+
+
+# --- Native ---
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_native_transfers_standard_url(client, parquet_bytes):
+    route = respx.post(f"{BASE}/native_transfers/read").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.native.transfers().network("ETH").time_range("2025-01-01", "2025-01-02").fetch()
+    assert route.called
+
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_native_transfers_min_amount_url(client, parquet_bytes):
+    route = respx.post(f"{BASE}/native_transfers/read/min").mock(
+        return_value=httpx.Response(200, content=parquet_bytes, headers={"content-type": "application/octet-stream"})
+    )
+    await client.native.transfers().network("ETH").time_range("2025-01-01", "2025-01-02").min_amount(0.5).fetch()
+    assert route.called
+    body = json.loads(route.calls[0].request.content)
+    assert body["min_amount"] == 0.5
+
+
+# --- Cache ---
+
+@respx.mock
+@pytest.mark.asyncio
+async def test_cache_flush(client):
+    route = respx.post(f"{BASE}/cache/flush").mock(
+        return_value=httpx.Response(200, content=b"{}", headers={"content-type": "application/json"})
+    )
+    await client.cache.flush()
+    assert route.called