defipipe 0.1.0__tar.gz

defipipe-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# deps
+node_modules/
+.pnpm-store/
+
+# builds
+.next/
+dist/
+out/
+.turbo/
+
+# ponder
+apps/indexer/.ponder/
+apps/indexer/generated/
+
+# env
+.env
+.env.*
+!.env.example
+
+# misc
+.DS_Store
+*.log
+
+# python
+__pycache__/
+*.egg-info/
+.venv/
+*.tsbuildinfo
+.vercel

defipipe-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: defipipe
+Version: 0.1.0
+Summary: Per-block, point-in-time DeFi contract state as pandas DataFrames — Aave rates, Uniswap prices, Lido supply, aligned onto one time axis.
+Project-URL: Homepage, https://defipipe.io
+Project-URL: Documentation, https://defipipe.io/docs
+Author: defipipe
+License-Expression: MIT
+Keywords: aave,blockchain-data,defi,ethereum,historical-data,lido,pandas,quant,time-series,uniswap
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Requires-Dist: pandas>=1.5
+Requires-Dist: requests>=2.28
+Description-Content-Type: text/markdown
+
+# defipipe — per-block DeFi state as pandas DataFrames
+
+**What read functions actually returned at every Ethereum block** — Aave borrow
+rates, Uniswap slot0 prices, Lido total staked ETH — reconstructed historically,
+indexed live, and aligned onto one clean time axis.
+
+Most DeFi data is built from *events*. defipipe serves *state*: the result of
+calling a contract's read functions at a specific block. If you need to know
+what the Aave WETH borrow rate actually was at block 19,000,000 — not an hourly
+average from a dashboard — this is the API for it.
+
+## Install
+
+```bash
+pip install defipipe
+```
+
+## Five lines to an aligned DataFrame
+
+```python
+from defipipe import Client
+
+df = Client().aligned([
+    "eth:aave:v3:0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2/weth:call:getreservedata[currentvariableborrowrate]",
+    "eth:lido:v2:0xae7ab96520de3a18e5e111b5eaab095312d7fe84:call:gettotalpooledether",
+], freq="1h", since="2026-01-01")
+
+df.corr()
+```
+
+No API key needed for recent data at hourly bars. Full history and per-block
+granularity: get a key at https://defipipe.io/pricing and set
+`DEFIPIPE_API_KEY` (or pass `api_key=`).
+
+## Why quants use this
+
+- **Point-in-time correctness.** Every value is the last observation **at or
+  before** each interval boundary, resolved through the block↔timestamp map.
+  No interpolation, no lookahead bias — safe for backtests.
+- **Exact raw values.** `client.series(id)` returns `value_raw` as the exact
+  on-chain string (uint256-safe) alongside the unit-scaled float.
+- **One key for everything.** Canonical series IDs
+  (`{chain}:{protocol}:{version}:{instance}[/{scope}]:{kind}:{metric}`) name
+  every series across protocols — browse them at https://defipipe.io/datasets.
+- **Per-block granularity** back to each pool's deployment, from our own
+  archive node — not sampled snapshots.
+
+## Raw per-block rows
+
+```python
+raw = Client(api_key="dp_...").series(
+    "eth:uniswap:v3:0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640:call:slot0[sqrtpricex96]",
+    since="2026-06-01",
+)
+raw.head()  # block_number → ts, value_raw, value
+```
+
+## Coverage
+
+Aave V3, Uniswap V3, Lido today; Morpho, GMX V2, Uniswap V4, Ethena, Maple
+next. Request a pool at https://defipipe.io/feature-requests — approved
+requests ship with full backfilled history.

defipipe-0.1.0/README.md

@@ -0,0 +1,62 @@
+# defipipe — per-block DeFi state as pandas DataFrames
+
+**What read functions actually returned at every Ethereum block** — Aave borrow
+rates, Uniswap slot0 prices, Lido total staked ETH — reconstructed historically,
+indexed live, and aligned onto one clean time axis.
+
+Most DeFi data is built from *events*. defipipe serves *state*: the result of
+calling a contract's read functions at a specific block. If you need to know
+what the Aave WETH borrow rate actually was at block 19,000,000 — not an hourly
+average from a dashboard — this is the API for it.
+
+## Install
+
+```bash
+pip install defipipe
+```
+
+## Five lines to an aligned DataFrame
+
+```python
+from defipipe import Client
+
+df = Client().aligned([
+    "eth:aave:v3:0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2/weth:call:getreservedata[currentvariableborrowrate]",
+    "eth:lido:v2:0xae7ab96520de3a18e5e111b5eaab095312d7fe84:call:gettotalpooledether",
+], freq="1h", since="2026-01-01")
+
+df.corr()
+```
+
+No API key needed for recent data at hourly bars. Full history and per-block
+granularity: get a key at https://defipipe.io/pricing and set
+`DEFIPIPE_API_KEY` (or pass `api_key=`).
+
+## Why quants use this
+
+- **Point-in-time correctness.** Every value is the last observation **at or
+  before** each interval boundary, resolved through the block↔timestamp map.
+  No interpolation, no lookahead bias — safe for backtests.
+- **Exact raw values.** `client.series(id)` returns `value_raw` as the exact
+  on-chain string (uint256-safe) alongside the unit-scaled float.
+- **One key for everything.** Canonical series IDs
+  (`{chain}:{protocol}:{version}:{instance}[/{scope}]:{kind}:{metric}`) name
+  every series across protocols — browse them at https://defipipe.io/datasets.
+- **Per-block granularity** back to each pool's deployment, from our own
+  archive node — not sampled snapshots.
+
+## Raw per-block rows
+
+```python
+raw = Client(api_key="dp_...").series(
+    "eth:uniswap:v3:0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640:call:slot0[sqrtpricex96]",
+    since="2026-06-01",
+)
+raw.head()  # block_number → ts, value_raw, value
+```
+
+## Coverage
+
+Aave V3, Uniswap V3, Lido today; Morpho, GMX V2, Uniswap V4, Ethena, Maple
+next. Request a pool at https://defipipe.io/feature-requests — approved
+requests ship with full backfilled history.

defipipe-0.1.0/defipipe/__init__.py

@@ -0,0 +1,6 @@
+"""defipipe — per-block DeFi contract state as pandas DataFrames."""
+
+from .client import Client, DefipipeError
+
+__version__ = "0.1.0"
+__all__ = ["Client", "DefipipeError"]

defipipe-0.1.0/defipipe/client.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import os
+from datetime import datetime, timezone
+from typing import Iterable, Optional, Union
+
+import pandas as pd
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+Timestampish = Union[str, datetime, None]
+
+DEFAULT_BASE_URL = "https://api.defipipe.io"
+
+
+class DefipipeError(RuntimeError):
+    """Raised when the API returns an error response."""
+
+    def __init__(self, status: int, message: str):
+        self.status = status
+        super().__init__(f"[{status}] {message}")
+
+
+def _iso(t: Timestampish) -> Optional[str]:
+    if t is None:
+        return None
+    if isinstance(t, datetime):
+        if t.tzinfo is None:
+            t = t.replace(tzinfo=timezone.utc)
+        return t.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    return t  # assume ISO-8601 string (or anything Date.parse accepts)
+
+
+class Client:
+    """defipipe API client.
+
+    >>> from defipipe import Client
+    >>> df = Client().aligned([
+    ...     "eth:aave:v3:0x8787.../weth:call:getreservedata[currentvariableborrowrate]",
+    ...     "eth:uniswap:v3:0x88e6...:call:slot0[sqrtpricex96]",
+    ... ], freq="1h", since="2026-01-01")
+
+    No API key is needed for recent data at coarse frequencies (free tier).
+    Set ``DEFIPIPE_API_KEY`` (or pass ``api_key=``) for full history and
+    per-block granularity.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ):
+        self.api_key = api_key or os.environ.get("DEFIPIPE_API_KEY")
+        self.base_url = (
+            base_url or os.environ.get("DEFIPIPE_API_URL", DEFAULT_BASE_URL)
+        ).rstrip("/")
+        self.timeout = timeout
+        self._http = requests.Session()
+        retry = Retry(
+            total=max_retries,
+            backoff_factor=0.5,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["GET"],
+        )
+        self._http.mount("http://", HTTPAdapter(max_retries=retry))
+        self._http.mount("https://", HTTPAdapter(max_retries=retry))
+
+    def _get(self, path: str, params: dict) -> dict:
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        r = self._http.get(
+            f"{self.base_url}{path}",
+            params={k: v for k, v in params.items() if v is not None},
+            headers=headers,
+            timeout=self.timeout,
+        )
+        if r.status_code >= 400:
+            try:
+                msg = r.json().get("error", r.text)
+            except ValueError:
+                msg = r.text
+            raise DefipipeError(r.status_code, msg)
+        return r.json()
+
+    def aligned(
+        self,
+        series: Iterable[str],
+        freq: str = "1h",
+        since: Timestampish = None,
+        until: Timestampish = None,
+    ) -> pd.DataFrame:
+        """Heterogeneous series resampled onto one timestamp axis.
+
+        Semantics: for each interval boundary, the **last value at or before**
+        that boundary (resolved server-side through the block↔time map) — no
+        interpolation, no lookahead.
+        """
+        ids = list(series)
+        data = self._get(
+            "/v1/aligned",
+            {
+                "series": ",".join(ids),
+                "freq": freq,
+                "from": _iso(since),
+                "to": _iso(until),
+            },
+        )
+        idx = pd.DatetimeIndex(pd.to_datetime(data["index"], utc=True), name="ts")
+        return pd.DataFrame({i: data["series"][i] for i in ids}, index=idx)
+
+    def series(
+        self,
+        series_id: str,
+        since: Timestampish = None,
+        until: Timestampish = None,
+        limit: int = 1000,
+    ) -> pd.DataFrame:
+        """Raw per-block rows for one canonical series (paginates transparently).
+
+        Columns: ``block_number``, ``ts``, ``value_raw`` (exact on-chain value
+        as a string — uint256-safe), ``value`` (unit-scaled float).
+        """
+        rows: list = []
+        after: Optional[int] = None
+        while True:
+            data = self._get(
+                f"/v1/series/{requests.utils.quote(series_id, safe='')}",
+                {
+                    "from": _iso(since),
+                    "to": _iso(until),
+                    "limit": limit,
+                    "after_block": after,
+                },
+            )
+            rows.extend(data["rows"])
+            after = data.get("next_after_block")
+            if after is None:
+                break
+        df = pd.DataFrame(rows, columns=["block_number", "ts", "value_raw", "value"])
+        if len(df):
+            df["ts"] = pd.to_datetime(df["ts"], unit="s", utc=True)
+        return df.set_index("block_number")

defipipe-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "defipipe"
+version = "0.1.0"
+description = "Per-block, point-in-time DeFi contract state as pandas DataFrames — Aave rates, Uniswap prices, Lido supply, aligned onto one time axis."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [{ name = "defipipe" }]
+keywords = [
+  "defi", "ethereum", "blockchain-data", "pandas", "quant",
+  "aave", "uniswap", "lido", "historical-data", "time-series",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Financial and Insurance Industry",
+  "Programming Language :: Python :: 3",
+  "Topic :: Office/Business :: Financial :: Investment",
+]
+dependencies = [
+  "pandas>=1.5",
+  "requests>=2.28",
+]
+
+[project.urls]
+Homepage = "https://defipipe.io"
+Documentation = "https://defipipe.io/docs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["defipipe"]