defillama-sdk 0.1.0__py3-none-any.whl

defillama_api/modules/fees.py

@@ -0,0 +1,242 @@
+"""Fees module implementation."""
+
+from typing import Optional
+from urllib.parse import quote
+
+from ..client import BaseClient
+from ..types.fees import (
+    ChartBreakdownDataPoint,
+    ChartDataPoint,
+    FeesChartOptions,
+    FeesMetricsByProtocolResponse,
+    FeesMetricsResponse,
+    FeesOverviewOptions,
+    FeesOverviewResponse,
+    FeesSummaryOptions,
+    FeesSummaryResponse,
+)
+
+
+def _data_type_value(value: Optional[object]) -> Optional[str]:
+    if value is None:
+        return None
+    if hasattr(value, "value"):
+        return str(getattr(value, "value"))
+    return str(value)
+
+
+class FeesModule:
+    """Access fees and revenue data from DefiLlama."""
+
+    def __init__(self, client: BaseClient) -> None:
+        self._client = client
+
+    def getOverview(self, options: Optional[FeesOverviewOptions] = None) -> FeesOverviewResponse:
+        """Get fees overview across all protocols."""
+
+        params = {}
+        if options:
+            if options.get("excludeTotalDataChart") is not None:
+                params["excludeTotalDataChart"] = options.get("excludeTotalDataChart")
+            if options.get("excludeTotalDataChartBreakdown") is not None:
+                params["excludeTotalDataChartBreakdown"] = options.get(
+                    "excludeTotalDataChartBreakdown"
+                )
+            data_type = _data_type_value(options.get("dataType"))
+            if data_type:
+                params["dataType"] = data_type
+        return self._client.get(
+            "/overview/fees",
+            params=params or None,
+        )
+
+    def getOverviewByChain(
+        self, chain: str, options: Optional[FeesOverviewOptions] = None
+    ) -> FeesOverviewResponse:
+        """Get fees overview for a chain."""
+
+        params = {}
+        if options:
+            if options.get("excludeTotalDataChart") is not None:
+                params["excludeTotalDataChart"] = options.get("excludeTotalDataChart")
+            if options.get("excludeTotalDataChartBreakdown") is not None:
+                params["excludeTotalDataChartBreakdown"] = options.get(
+                    "excludeTotalDataChartBreakdown"
+                )
+            data_type = _data_type_value(options.get("dataType"))
+            if data_type:
+                params["dataType"] = data_type
+        return self._client.get(
+            f"/overview/fees/{quote(chain)}",
+            params=params or None,
+        )
+
+    def getSummary(
+        self, protocol: str, options: Optional[FeesSummaryOptions] = None
+    ) -> FeesSummaryResponse:
+        """Get fees summary for a protocol."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            f"/summary/fees/{quote(protocol)}",
+            params=params or None,
+        )
+
+    def getChart(self, options: Optional[FeesChartOptions] = None) -> list[ChartDataPoint]:
+        """Get historical fees chart."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            "/chart/fees",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )
+
+    def getChartByChain(
+        self, chain: str, options: Optional[FeesChartOptions] = None
+    ) -> list[ChartDataPoint]:
+        """Get historical fees chart for a chain."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            f"/chart/fees/chain/{quote(chain)}",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )
+
+    def getChartByProtocol(
+        self, protocol: str, options: Optional[FeesChartOptions] = None
+    ) -> list[ChartDataPoint]:
+        """Get historical fees chart for a protocol."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            f"/chart/fees/protocol/{quote(protocol)}",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )
+
+    def getChartByProtocolChainBreakdown(
+        self, protocol: str, options: Optional[FeesChartOptions] = None
+    ) -> list[ChartBreakdownDataPoint]:
+        """Get fees chart with protocol chain breakdown."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            f"/chart/fees/protocol/{quote(protocol)}/chain-breakdown",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )
+
+    def getChartByProtocolVersionBreakdown(
+        self, protocol: str, options: Optional[FeesChartOptions] = None
+    ) -> list[ChartBreakdownDataPoint]:
+        """Get fees chart with protocol version breakdown."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            f"/chart/fees/protocol/{quote(protocol)}/version-breakdown",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )
+
+    def getChartByChainProtocolBreakdown(
+        self, chain: str, options: Optional[FeesChartOptions] = None
+    ) -> list[ChartBreakdownDataPoint]:
+        """Get fees chart with chain protocol breakdown."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            f"/chart/fees/chain/{quote(chain)}/protocol-breakdown",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )
+
+    def getChartChainBreakdown(
+        self, options: Optional[FeesChartOptions] = None
+    ) -> list[ChartBreakdownDataPoint]:
+        """Get fees chart with chain breakdown across protocols."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            "/chart/fees/chain-breakdown",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )
+
+    def getMetrics(self, options: Optional[FeesChartOptions] = None) -> FeesMetricsResponse:
+        """Get fee metrics across protocols."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            "/metrics/fees",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )
+
+    def getMetricsByChain(
+        self, chain: str, options: Optional[FeesChartOptions] = None
+    ) -> FeesMetricsResponse:
+        """Get fee metrics for a chain."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            f"/metrics/fees/chain/{quote(chain)}",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )
+
+    def getMetricsByProtocol(
+        self, protocol: str, options: Optional[FeesChartOptions] = None
+    ) -> FeesMetricsByProtocolResponse:
+        """Get fee metrics for a protocol."""
+
+        params = {}
+        data_type = _data_type_value(options.get("dataType") if options else None)
+        if data_type:
+            params["dataType"] = data_type
+        return self._client.get(
+            f"/metrics/fees/protocol/{quote(protocol)}",
+            base="v2",
+            requires_auth=True,
+            params=params or None,
+        )

defillama_api/modules/prices.py

@@ -0,0 +1,122 @@
+"""Prices module implementation."""
+
+import json
+from typing import Dict, List, Optional
+from urllib.parse import quote
+
+from ..client import BaseClient
+from ..types.prices import (
+    BatchHistoricalResponse,
+    BlockInfo,
+    ChartOptions,
+    ChartResponse,
+    CoinPricesResponse,
+    FirstPriceResponse,
+    PercentageOptions,
+    PercentageResponse,
+)
+
+
+class PricesModule:
+    """Access token price data from DefiLlama."""
+
+    def __init__(self, client: BaseClient) -> None:
+        self._client = client
+
+    def getCurrentPrices(
+        self, coins: List[str], searchWidth: Optional[str] = None
+    ) -> CoinPricesResponse:
+        """Get current prices for multiple tokens."""
+
+        coins_param = ",".join(coins)
+        params = {"searchWidth": searchWidth} if searchWidth else None
+        return self._client.get(
+            f"/prices/current/{coins_param}",
+            base="coins",
+            params=params,
+        )
+
+    def getHistoricalPrices(
+        self, timestamp: int, coins: List[str], searchWidth: Optional[str] = None
+    ) -> CoinPricesResponse:
+        """Get historical prices at a specific timestamp."""
+
+        coins_param = ",".join(coins)
+        params = {"searchWidth": searchWidth} if searchWidth else None
+        return self._client.get(
+            f"/prices/historical/{timestamp}/{coins_param}",
+            base="coins",
+            params=params,
+        )
+
+    def getBatchHistoricalPrices(
+        self, coins: Dict[str, List[int]], searchWidth: Optional[str] = None
+    ) -> BatchHistoricalResponse:
+        """Get multiple historical price points in one request."""
+
+        params = {
+            "coins": json.dumps(coins),
+            "searchWidth": searchWidth,
+        }
+        return self._client.get(
+            "/batchHistorical",
+            base="coins",
+            params=params,
+        )
+
+    def getChart(
+        self, coins: List[str], options: Optional[ChartOptions] = None
+    ) -> ChartResponse:
+        """Get price chart data at regular intervals."""
+
+        coins_param = ",".join(coins)
+        params = None
+        if options:
+            params = {
+                "start": options.get("start"),
+                "end": options.get("end"),
+                "span": options.get("span"),
+                "period": options.get("period"),
+                "searchWidth": options.get("searchWidth"),
+            }
+        return self._client.get(
+            f"/chart/{coins_param}",
+            base="coins",
+            params=params,
+        )
+
+    def getPercentageChange(
+        self, coins: List[str], options: Optional[PercentageOptions] = None
+    ) -> PercentageResponse:
+        """Get percentage price change over a period."""
+
+        coins_param = ",".join(coins)
+        params = None
+        if options:
+            params = {
+                "timestamp": options.get("timestamp"),
+                "lookForward": options.get("lookForward"),
+                "period": options.get("period"),
+            }
+        return self._client.get(
+            f"/percentage/{coins_param}",
+            base="coins",
+            params=params,
+        )
+
+    def getFirstPrices(self, coins: List[str]) -> FirstPriceResponse:
+        """Get the earliest recorded price for tokens."""
+
+        coins_param = ",".join(coins)
+        return self._client.get(
+            f"/prices/first/{coins_param}",
+            base="coins",
+        )
+
+    def getBlockAtTimestamp(self, chain: str, timestamp: int) -> BlockInfo:
+        """Get the closest block to a given timestamp."""
+
+        return self._client.get(
+            f"/block/{quote(chain)}/{timestamp}",
+            base="coins",
+        )

defillama_api/modules/stablecoins.py

@@ -0,0 +1,76 @@
+"""Stablecoins module implementation."""
+
+from typing import List, Optional
+from urllib.parse import quote
+
+from ..client import BaseClient
+from ..types.stablecoins import (
+    StablecoinChainDataPoint,
+    StablecoinChainMcap,
+    StablecoinChartDataPoint,
+    StablecoinDetails,
+    StablecoinDominanceDataPoint,
+    StablecoinPricePoint,
+    StablecoinsResponse,
+)
+
+
+class StablecoinsModule:
+    """Access stablecoin data from DefiLlama."""
+
+    def __init__(self, client: BaseClient) -> None:
+        self._client = client
+
+    def getStablecoins(self, includePrices: Optional[bool] = None) -> StablecoinsResponse:
+        """Get all stablecoins with current market caps."""
+
+        params = {"includePrices": includePrices} if includePrices is not None else None
+        return self._client.get(
+            "/stablecoins",
+            base="stablecoins",
+            params=params,
+        )
+
+    def getAllCharts(self) -> List[StablecoinChartDataPoint]:
+        """Get historical market cap data for all stablecoins."""
+
+        return self._client.get("/stablecoincharts/all", base="stablecoins")
+
+    def getChartsByChain(self, chain: str) -> List[StablecoinChainDataPoint]:
+        """Get historical market cap data for stablecoins on a chain."""
+
+        return self._client.get(
+            f"/stablecoincharts/{quote(chain)}",
+            base="stablecoins",
+        )
+
+    def getStablecoin(self, asset: str) -> StablecoinDetails:
+        """Get detailed information about a stablecoin."""
+
+        return self._client.get(
+            f"/stablecoin/{quote(asset)}",
+            base="stablecoins",
+        )
+
+    def getChains(self) -> List[StablecoinChainMcap]:
+        """Get stablecoin market cap for all chains."""
+
+        return self._client.get("/stablecoinchains", base="stablecoins")
+
+    def getPrices(self) -> List[StablecoinPricePoint]:
+        """Get historical prices for all stablecoins."""
+
+        return self._client.get("/stablecoinprices", base="stablecoins")
+
+    def getDominance(
+        self, chain: str, stablecoinId: Optional[int] = None
+    ) -> List[StablecoinDominanceDataPoint]:
+        """Get stablecoin dominance data for a chain."""
+
+        params = {"stablecoin": stablecoinId} if stablecoinId is not None else None
+        return self._client.get(
+            f"/stablecoindominance/{quote(chain)}",
+            requires_auth=True,
+            api_namespace="stablecoins",
+            params=params,
+        )

defillama_api/modules/tvl.py

@@ -0,0 +1,84 @@
+"""TVL module implementation."""
+
+from typing import List, Optional, Union
+from urllib.parse import quote
+
+from ..client import BaseClient
+from ..types.tvl import (
+    Chain,
+    ChainAssetsResponse,
+    HistoricalChainTvl,
+    HistoricalChainsTvl,
+    Protocol,
+    ProtocolDetails,
+    ProtocolInflowsResponse,
+    TokenProtocolHolding,
+)
+
+
+class TvlModule:
+    """Access TVL data from DefiLlama."""
+
+    def __init__(self, client: BaseClient) -> None:
+        self._client = client
+
+    def getProtocols(self) -> List[Protocol]:
+        """Get all protocols with current TVL."""
+
+        return self._client.get("/protocols")
+
+    def getProtocol(self, protocol: str) -> ProtocolDetails:
+        """Get detailed protocol information with historical TVL."""
+
+        return self._client.get(f"/protocol/{quote(protocol)}")
+
+    def getTvl(self, protocol: str) -> float:
+        """Get current TVL for a protocol."""
+
+        return self._client.get(f"/tvl/{quote(protocol)}")
+
+    def getChains(self) -> List[Chain]:
+        """Get current TVL for all chains."""
+
+        return self._client.get("/v2/chains")
+
+    def getHistoricalChainTvl(
+        self, chain: Optional[str] = None
+    ) -> Union[List[HistoricalChainsTvl], List[HistoricalChainTvl]]:
+        """Get historical TVL data for all chains or a specific chain."""
+
+        if chain:
+            return self._client.get(f"/v2/historicalChainTvl/{quote(chain)}")
+        return self._client.get("/v2/historicalChainTvl")
+
+    def getTokenProtocols(self, symbol: str) -> List[TokenProtocolHolding]:
+        """Get protocols that hold a specific token."""
+
+        return self._client.get(
+            f"/tokenProtocols/{quote(symbol)}",
+            requires_auth=True,
+        )
+
+    def getInflows(
+        self,
+        protocol: str,
+        start_timestamp: int,
+        end_timestamp: int,
+        tokens_to_exclude: Optional[str] = None,
+    ) -> ProtocolInflowsResponse:
+        """Get token inflows/outflows for a protocol."""
+
+        params = {
+            "end": end_timestamp,
+            "tokensToExclude": tokens_to_exclude or "",
+        }
+        return self._client.get(
+            f"/inflows/{quote(protocol)}/{start_timestamp}",
+            requires_auth=True,
+            params=params,
+        )
+
+    def getChainAssets(self) -> ChainAssetsResponse:
+        """Get asset breakdown for all chains."""
+
+        return self._client.get("/chainAssets", requires_auth=True)

defillama_api/modules/volumes.py

@@ -0,0 +1,116 @@
+"""Volumes module implementation."""
+
+from typing import Optional
+from urllib.parse import quote
+
+from ..client import BaseClient
+from ..types.volumes import (
+    DexOverviewOptions,
+    DexOverviewResponse,
+    DexSummaryOptions,
+    DexSummaryResponse,
+    DerivativesOverviewResponse,
+    DerivativesSummaryResponse,
+    OptionsOverviewOptions,
+    OptionsOverviewResponse,
+    OptionsSummaryResponse,
+)
+
+
+class VolumesModule:
+    """Access volume data from DefiLlama."""
+
+    def __init__(self, client: BaseClient) -> None:
+        self._client = client
+
+    def getDexOverview(
+        self, options: Optional[DexOverviewOptions] = None
+    ) -> DexOverviewResponse:
+        """Get overview of DEX volume data."""
+
+        params = {}
+        if options:
+            if options.get("excludeTotalDataChart") is not None:
+                params["excludeTotalDataChart"] = options.get("excludeTotalDataChart")
+            if options.get("excludeTotalDataChartBreakdown") is not None:
+                params["excludeTotalDataChartBreakdown"] = options.get(
+                    "excludeTotalDataChartBreakdown"
+                )
+            if options.get("dataType"):
+                params["dataType"] = options.get("dataType")
+        return self._client.get(
+            "/overview/dexs",
+            params=params or None,
+        )
+
+    def getDexOverviewByChain(
+        self, chain: str, options: Optional[DexOverviewOptions] = None
+    ) -> DexOverviewResponse:
+        """Get DEX volume overview for a chain."""
+
+        params = {}
+        if options:
+            if options.get("excludeTotalDataChart") is not None:
+                params["excludeTotalDataChart"] = options.get("excludeTotalDataChart")
+            if options.get("excludeTotalDataChartBreakdown") is not None:
+                params["excludeTotalDataChartBreakdown"] = options.get(
+                    "excludeTotalDataChartBreakdown"
+                )
+        return self._client.get(
+            f"/overview/dexs/{quote(chain)}",
+            params=params or None,
+        )
+
+    def getDexSummary(
+        self, protocol: str, options: Optional[DexSummaryOptions] = None
+    ) -> DexSummaryResponse:
+        """Get DEX volume summary for a protocol."""
+
+        params = {}
+        if options and options.get("dataType"):
+            params["dataType"] = options.get("dataType")
+        return self._client.get(
+            f"/summary/dexs/{quote(protocol)}",
+            params=params or None,
+        )
+
+    def getOptionsOverview(
+        self, options: Optional[OptionsOverviewOptions] = None
+    ) -> OptionsOverviewResponse:
+        """Get options volume overview."""
+
+        params = {}
+        if options:
+            if options.get("excludeTotalDataChart") is not None:
+                params["excludeTotalDataChart"] = options.get("excludeTotalDataChart")
+            if options.get("excludeTotalDataChartBreakdown") is not None:
+                params["excludeTotalDataChartBreakdown"] = options.get(
+                    "excludeTotalDataChartBreakdown"
+                )
+        return self._client.get(
+            "/overview/options",
+            params=params or None,
+        )
+
+    def getOptionsOverviewByChain(self, chain: str) -> OptionsOverviewResponse:
+        """Get options volume for a chain."""
+
+        return self._client.get(f"/overview/options/{quote(chain)}")
+
+    def getOptionsSummary(self, protocol: str) -> OptionsSummaryResponse:
+        """Get options volume summary for a protocol."""
+
+        return self._client.get(f"/summary/options/{quote(protocol)}")
+
+    def getDerivativesOverview(self) -> DerivativesOverviewResponse:
+        """Get derivatives volume overview."""
+
+        return self._client.get("/overview/derivatives", requires_auth=True)
+
+    def getDerivativesSummary(self, protocol: str) -> DerivativesSummaryResponse:
+        """Get derivatives volume summary for a protocol."""
+
+        return self._client.get(
+            f"/summary/derivatives/{quote(protocol)}",
+            requires_auth=True,
+        )