defillama-sdk 0.1.0__py3-none-any.whl

defillama_api/modules/yields.py

@@ -0,0 +1,85 @@
+"""Yields module implementation."""
+
+from typing import List
+from urllib.parse import quote
+
+from ..client import BaseClient
+from ..types.yields import (
+    BorrowPoolsResponse,
+    LendBorrowChartResponse,
+    LsdRate,
+    PerpsResponse,
+    YieldChartResponse,
+    YieldPoolsOldResponse,
+    YieldPoolsResponse,
+)
+
+
+class YieldsModule:
+    """Access yield data from DefiLlama."""
+
+    def __init__(self, client: BaseClient) -> None:
+        self._client = client
+
+    def getPools(self) -> YieldPoolsResponse:
+        """Get all yield pools with current APY."""
+
+        return self._client.get(
+            "/pools",
+            requires_auth=True,
+            api_namespace="yields",
+        )
+
+    def getPoolsOld(self) -> YieldPoolsOldResponse:
+        """Get yield pools in legacy format."""
+
+        return self._client.get(
+            "/poolsOld",
+            requires_auth=True,
+            api_namespace="yields",
+        )
+
+    def getPoolChart(self, pool: str) -> YieldChartResponse:
+        """Get historical APY and TVL for a pool."""
+
+        return self._client.get(
+            f"/chart/{quote(pool)}",
+            requires_auth=True,
+            api_namespace="yields",
+        )
+
+    def getBorrowPools(self) -> BorrowPoolsResponse:
+        """Get lending/borrowing pools."""
+
+        return self._client.get(
+            "/poolsBorrow",
+            requires_auth=True,
+            api_namespace="yields",
+        )
+
+    def getLendBorrowChart(self, pool: str) -> LendBorrowChartResponse:
+        """Get historical lend/borrow rates."""
+
+        return self._client.get(
+            f"/chartLendBorrow/{quote(pool)}",
+            requires_auth=True,
+            api_namespace="yields",
+        )
+
+    def getPerps(self) -> PerpsResponse:
+        """Get perpetual futures funding rates."""
+
+        return self._client.get(
+            "/perps",
+            requires_auth=True,
+            api_namespace="yields",
+        )
+
+    def getLsdRates(self) -> List[LsdRate]:
+        """Get liquid staking derivative rates."""
+
+        return self._client.get(
+            "/lsdRates",
+            requires_auth=True,
+            api_namespace="yields",
+        )

defillama_api/types/__init__.py

@@ -0,0 +1,14 @@
+"""Type exports for DefiLlama API responses."""
+
+from .account import *
+from .bridges import *
+from .dat import *
+from .ecosystem import *
+from .emissions import *
+from .etfs import *
+from .fees import *
+from .prices import *
+from .stablecoins import *
+from .tvl import *
+from .volumes import *
+from .yields import *

defillama_api/types/account.py

@@ -0,0 +1,10 @@
+"""Account type definitions."""
+
+from typing import TypedDict
+
+
+class UsageResponse(TypedDict):
+    creditsLeft: int
+
+
+__all__ = ["UsageResponse"]

defillama_api/types/bridges.py

@@ -0,0 +1,147 @@
+"""Bridge type definitions."""
+
+from typing import Dict, List, Optional, TypedDict
+
+
+class TransactionCounts(TypedDict):
+    deposits: int
+    withdrawals: int
+
+
+class BridgeSummary(TypedDict, total=False):
+    id: int
+    defillamaId: Optional[str]
+    name: str
+    displayName: str
+    icon: Optional[str]
+    volumePrevDay: float
+    volumePrev2Day: Optional[float]
+    lastHourlyVolume: float
+    last24hVolume: float
+    lastDailyVolume: float
+    dayBeforeLastVolume: Optional[float]
+    weeklyVolume: Optional[float]
+    monthlyVolume: Optional[float]
+    chains: Optional[List[str]]
+    destinationChain: Optional[str]
+    url: Optional[str]
+    slug: Optional[str]
+
+
+class BridgeChainInfo(TypedDict, total=False):
+    gecko_id: Optional[str]
+    volumePrevDay: float
+    tokenSymbol: Optional[str]
+    name: str
+
+
+class BridgesResponse(TypedDict, total=False):
+    bridges: List[BridgeSummary]
+    chains: Optional[List[BridgeChainInfo]]
+
+
+class ChainVolumeBreakdown(TypedDict):
+    lastHourlyVolume: float
+    currentDayVolume: float
+    lastDailyVolume: float
+    dayBeforeLastVolume: float
+    weeklyVolume: float
+    monthlyVolume: float
+    last24hVolume: float
+    lastHourlyTxs: TransactionCounts
+    currentDayTxs: TransactionCounts
+    prevDayTxs: TransactionCounts
+    dayBeforeLastTxs: TransactionCounts
+    weeklyTxs: TransactionCounts
+    monthlyTxs: TransactionCounts
+
+
+class BridgeDetail(TypedDict, total=False):
+    id: int
+    name: str
+    displayName: str
+    lastHourlyVolume: float
+    currentDayVolume: float
+    lastDailyVolume: float
+    dayBeforeLastVolume: float
+    weeklyVolume: float
+    monthlyVolume: float
+    lastHourlyTxs: TransactionCounts
+    currentDayTxs: TransactionCounts
+    prevDayTxs: TransactionCounts
+    dayBeforeLastTxs: TransactionCounts
+    weeklyTxs: TransactionCounts
+    monthlyTxs: TransactionCounts
+    chainBreakdown: Optional[Dict[str, ChainVolumeBreakdown]]
+    destinationChain: Optional[str]
+
+
+class BridgeVolumeDataPoint(TypedDict):
+    date: str
+    depositUSD: float
+    withdrawUSD: float
+    depositTxs: int
+    withdrawTxs: int
+
+
+class TokenDayStats(TypedDict):
+    usdValue: float
+    amount: str
+    symbol: str
+    decimals: int
+
+
+class AddressDayStats(TypedDict):
+    usdValue: float
+    txs: int
+
+
+class BridgeDayStatsResponse(TypedDict):
+    date: int
+    totalTokensDeposited: Dict[str, TokenDayStats]
+    totalTokensWithdrawn: Dict[str, TokenDayStats]
+    totalAddressDeposited: Dict[str, AddressDayStats]
+    totalAddressWithdrawn: Dict[str, AddressDayStats]
+
+
+class BridgesOptions(TypedDict, total=False):
+    includeChains: Optional[bool]
+
+
+class BridgeTransactionsOptions(TypedDict, total=False):
+    limit: Optional[int]
+    startTimestamp: Optional[int]
+    endTimestamp: Optional[int]
+    sourceChain: Optional[str]
+    address: Optional[str]
+
+
+class BridgeTransaction(TypedDict, total=False):
+    tx_hash: str
+    ts: str
+    tx_block: int
+    tx_from: str
+    tx_to: str
+    token: str
+    amount: str
+    is_deposit: bool
+    chain: str
+    bridge_name: str
+    usd_value: Optional[float]
+
+
+__all__ = [
+    "TransactionCounts",
+    "BridgeSummary",
+    "BridgeChainInfo",
+    "BridgesResponse",
+    "ChainVolumeBreakdown",
+    "BridgeDetail",
+    "BridgeVolumeDataPoint",
+    "TokenDayStats",
+    "AddressDayStats",
+    "BridgeDayStatsResponse",
+    "BridgesOptions",
+    "BridgeTransactionsOptions",
+    "BridgeTransaction",
+]

defillama_api/types/dat.py

@@ -0,0 +1,144 @@
+"""Digital Asset Treasury type definitions."""
+
+from typing import Dict, List, Optional, Tuple, TypedDict, Union
+
+
+class InstitutionHolding(TypedDict, total=False):
+    amount: float
+    avgPrice: Optional[float]
+    usdValue: float
+    cost: Optional[float]
+    transactionCount: Optional[int]
+    firstAnnouncementDate: Optional[str]
+    lastAnnouncementDate: Optional[str]
+    supplyPercentage: Optional[float]
+
+
+class InstitutionMetadata(TypedDict, total=False):
+    institutionId: int
+    ticker: str
+    name: str
+    type: Optional[str]
+    price: Optional[float]
+    priceChange24h: Optional[float]
+    volume24h: Optional[float]
+    fd_realized: Optional[Union[float, str]]
+    fd_realistic: Optional[Union[float, str]]
+    fd_maximum: Optional[Union[float, str]]
+    mcapRealized: Optional[float]
+    mcapRealistic: Optional[float]
+    mcapMax: Optional[float]
+    realized_mNAV: Optional[float]
+    realistic_mNAV: Optional[float]
+    max_mNAV: Optional[float]
+    totalCost: Optional[float]
+    totalUsdValue: Optional[float]
+    holdings: Optional[Dict[str, InstitutionHolding]]
+    description: Optional[str]
+    logo: Optional[str]
+    url: Optional[str]
+    country: Optional[str]
+    exchange: Optional[str]
+    marketCap: Optional[float]
+    totalBitcoin: Optional[float]
+    totalEthereum: Optional[float]
+
+
+class DatAssetMetadata(TypedDict, total=False):
+    name: str
+    ticker: str
+    geckoId: Optional[str]
+    companies: Optional[int]
+    totalAmount: Optional[float]
+    totalUsdValue: Optional[float]
+    circSupplyPerc: Optional[float]
+
+
+class DatInstitutionSummary(TypedDict):
+    institutionId: int
+    totalUsdValue: float
+    totalCost: Optional[float]
+
+
+class DatAssetInstitutionSummary(TypedDict):
+    institutionId: int
+    usdValue: float
+    amount: float
+
+
+DatFlowPoint = Tuple[float, float, float, float, float, float]
+DatMnavPoint = Tuple[float, float, float, float]
+DatStatsPoint = Tuple[
+    float,
+    float,
+    float,
+    float,
+    float,
+    float,
+    float,
+    float,
+    float,
+    float,
+]
+DatOhlcvPoint = Tuple[float, float, float, float, float, float]
+
+
+class DatInstitutionsResponse(TypedDict, total=False):
+    institutionMetadata: Dict[str, InstitutionMetadata]
+    assetMetadata: Dict[str, DatAssetMetadata]
+    institutions: List[DatInstitutionSummary]
+    assets: Dict[str, List[DatAssetInstitutionSummary]]
+    flows: Optional[Dict[str, List[DatFlowPoint]]]
+    mNAV: Optional[Dict[str, Dict[str, List[DatMnavPoint]]]]
+    totalCompanies: int
+    lastUpdated: str
+
+
+class DatInstitutionAssetMeta(TypedDict):
+    name: str
+    ticker: str
+
+
+class DatInstitutionResponse(TypedDict, total=False):
+    institutionId: int
+    ticker: str
+    name: str
+    type: Optional[str]
+    rank: Optional[int]
+    price: Optional[float]
+    priceChange24h: Optional[float]
+    volume24h: Optional[float]
+    fd_realized: Optional[Union[float, str]]
+    fd_realistic: Optional[Union[float, str]]
+    fd_max: Optional[Union[float, str]]
+    mcap_realized: Optional[float]
+    mcap_realistic: Optional[float]
+    mcap_max: Optional[float]
+    realized_mNAV: Optional[float]
+    realistic_mNAV: Optional[float]
+    max_mNAV: Optional[float]
+    totalCost: Optional[float]
+    totalUsdValue: Optional[float]
+    assets: Optional[Dict[str, InstitutionHolding]]
+    assetsMeta: Optional[Dict[str, DatInstitutionAssetMeta]]
+    assetValue: Optional[List[Tuple[float, float]]]
+    stats: Optional[List[DatStatsPoint]]
+    ohlcv: Optional[List[DatOhlcvPoint]]
+    transactions: Optional[List[object]]
+    lastUpdated: Optional[str]
+
+
+__all__ = [
+    "InstitutionHolding",
+    "InstitutionMetadata",
+    "DatAssetMetadata",
+    "DatInstitutionSummary",
+    "DatAssetInstitutionSummary",
+    "DatFlowPoint",
+    "DatMnavPoint",
+    "DatStatsPoint",
+    "DatOhlcvPoint",
+    "DatInstitutionsResponse",
+    "DatInstitutionAssetMeta",
+    "DatInstitutionResponse",
+]

defillama_api/types/ecosystem.py

@@ -0,0 +1,175 @@
+"""Ecosystem type definitions."""
+
+from typing import Dict, List, Optional, TypedDict
+
+
+class CategoryTvlDataPoint(TypedDict, total=False):
+    tvl: Optional[float]
+
+
+class CategoriesResponse(TypedDict):
+    chart: Dict[str, Dict[str, CategoryTvlDataPoint]]
+    categories: Dict[str, List[str]]
+    categoryPercentages: Optional[Dict[str, float]]
+
+
+class ForkTvlDataPoint(TypedDict):
+    tvl: float
+    forks: Optional[float]
+
+
+class ForksResponse(TypedDict, total=False):
+    chart: Dict[str, Dict[str, ForkTvlDataPoint]]
+    forks: Dict[str, List[str]]
+    parentProtocols: Optional[Dict[str, str]]
+
+
+class OracleTvlDataPoint(TypedDict, total=False):
+    tvl: float
+    protocolsSecured: Optional[float]
+
+
+class OraclesResponse(TypedDict, total=False):
+    chart: Dict[str, Dict[str, OracleTvlDataPoint]]
+    chainChart: Optional[Dict[str, Dict[str, object]]]
+    oraclesTVS: Optional[Dict[str, object]]
+    oracles: Dict[str, List[str]]
+    chainsByOracle: Optional[Dict[str, List[str]]]
+    totalValueSecured: Optional[float]
+    dominance: Optional[Dict[str, float]]
+
+
+class TokenBreakdowns(TypedDict):
+    ownTokens: float
+    stablecoins: float
+    majors: float
+    others: float
+
+
+class Entity(TypedDict, total=False):
+    id: str
+    name: str
+    url: Optional[str]
+    description: Optional[str]
+    logo: Optional[str]
+    category: Optional[str]
+    module: Optional[str]
+    twitter: Optional[str]
+    symbol: Optional[str]
+    chain: Optional[str]
+    gecko_id: Optional[str]
+    cmcId: Optional[str]
+    chains: Optional[List[str]]
+    misrepresentedTokens: Optional[bool]
+    slug: Optional[str]
+    tvl: float
+    chainTvls: Optional[Dict[str, float]]
+    change_1h: Optional[float]
+    change_1d: Optional[float]
+    change_7d: Optional[float]
+    tokenBreakdowns: Optional[TokenBreakdowns]
+    mcap: Optional[float]
+
+
+class Treasury(TypedDict, total=False):
+    id: str
+    name: str
+    address: Optional[str]
+    symbol: Optional[str]
+    url: Optional[str]
+    description: Optional[str]
+    chain: Optional[str]
+    logo: Optional[str]
+    audits: Optional[str]
+    audit_note: Optional[str]
+    audit_links: Optional[List[str]]
+    gecko_id: Optional[str]
+    cmcId: Optional[str]
+    category: Optional[str]
+    chains: Optional[List[str]]
+    module: Optional[str]
+    treasury: Optional[str]
+    forkedFrom: Optional[List[str]]
+    forkedFromIds: Optional[List[str]]
+    twitter: Optional[str]
+    misrepresentedTokens: Optional[bool]
+    slug: Optional[str]
+    tvl: float
+    chainTvls: Optional[Dict[str, float]]
+    change_1h: Optional[float]
+    change_1d: Optional[float]
+    change_7d: Optional[float]
+    tokenBreakdowns: Optional[TokenBreakdowns]
+    mcap: Optional[float]
+    oracles: Optional[List[str]]
+    oraclesBreakdown: Optional[object]
+    listedAt: Optional[int]
+    methodology: Optional[str]
+    governanceID: Optional[List[str]]
+    stablecoins: Optional[List[str]]
+    referralUrl: Optional[str]
+    openSource: Optional[bool]
+    deadUrl: Optional[bool]
+    deadFrom: Optional[int]
+    github: Optional[List[str]]
+    language: Optional[str]
+    assetToken: Optional[str]
+    dimensions: Optional[Dict[str, object]]
+    hallmarks: Optional[List[List[object]]]
+    previousNames: Optional[List[str]]
+    rugged: Optional[bool]
+    tags: Optional[List[str]]
+    warningBanners: Optional[List[str]]
+    wrongLiquidity: Optional[bool]
+
+
+class Hack(TypedDict, total=False):
+    date: int
+    name: str
+    classification: str
+    technique: str
+    amount: Optional[float]
+    chain: List[str]
+    bridgeHack: Optional[bool]
+    targetType: Optional[str]
+    source: Optional[str]
+    returnedFunds: Optional[float]
+    defillamaId: Optional[object]
+    language: Optional[str]
+    parentProtocolId: Optional[str]
+
+
+class Raise(TypedDict, total=False):
+    date: int
+    name: str
+    round: Optional[str]
+    amount: float
+    chains: Optional[List[str]]
+    sector: Optional[str]
+    category: Optional[str]
+    categoryGroup: Optional[str]
+    source: Optional[str]
+    leadInvestors: List[str]
+    otherInvestors: Optional[List[str]]
+    valuation: Optional[float]
+    defillamaId: Optional[str]
+
+
+class RaisesResponse(TypedDict):
+    raises: List[Raise]
+
+
+__all__ = [
+    "CategoryTvlDataPoint",
+    "CategoriesResponse",
+    "ForkTvlDataPoint",
+    "ForksResponse",
+    "OracleTvlDataPoint",
+    "OraclesResponse",
+    "TokenBreakdowns",
+    "Entity",
+    "Treasury",
+    "Hack",
+    "Raise",
+    "RaisesResponse",
+]