intentkit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

intentkit/skills/defillama/__init__.py

@@ -0,0 +1,323 @@
+"""DeFi Llama skills."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.defillama.base import DefiLlamaBaseTool
+from intentkit.skills.defillama.coins.fetch_batch_historical_prices import (
+    DefiLlamaFetchBatchHistoricalPrices,
+)
+from intentkit.skills.defillama.coins.fetch_block import DefiLlamaFetchBlock
+
+# Coins Tools
+from intentkit.skills.defillama.coins.fetch_current_prices import (
+    DefiLlamaFetchCurrentPrices,
+)
+from intentkit.skills.defillama.coins.fetch_first_price import DefiLlamaFetchFirstPrice
+from intentkit.skills.defillama.coins.fetch_historical_prices import (
+    DefiLlamaFetchHistoricalPrices,
+)
+from intentkit.skills.defillama.coins.fetch_price_chart import DefiLlamaFetchPriceChart
+from intentkit.skills.defillama.coins.fetch_price_percentage import (
+    DefiLlamaFetchPricePercentage,
+)
+
+# Fees Tools
+from intentkit.skills.defillama.fees.fetch_fees_overview import (
+    DefiLlamaFetchFeesOverview,
+)
+from intentkit.skills.defillama.stablecoins.fetch_stablecoin_chains import (
+    DefiLlamaFetchStablecoinChains,
+)
+from intentkit.skills.defillama.stablecoins.fetch_stablecoin_charts import (
+    DefiLlamaFetchStablecoinCharts,
+)
+from intentkit.skills.defillama.stablecoins.fetch_stablecoin_prices import (
+    DefiLlamaFetchStablecoinPrices,
+)
+
+# Stablecoins Tools
+from intentkit.skills.defillama.stablecoins.fetch_stablecoins import (
+    DefiLlamaFetchStablecoins,
+)
+from intentkit.skills.defillama.tvl.fetch_chain_historical_tvl import (
+    DefiLlamaFetchChainHistoricalTvl,
+)
+from intentkit.skills.defillama.tvl.fetch_chains import DefiLlamaFetchChains
+from intentkit.skills.defillama.tvl.fetch_historical_tvl import (
+    DefiLlamaFetchHistoricalTvl,
+)
+from intentkit.skills.defillama.tvl.fetch_protocol import DefiLlamaFetchProtocol
+from intentkit.skills.defillama.tvl.fetch_protocol_current_tvl import (
+    DefiLlamaFetchProtocolCurrentTvl,
+)
+
+# TVL Tools
+from intentkit.skills.defillama.tvl.fetch_protocols import DefiLlamaFetchProtocols
+
+# Volumes Tools
+from intentkit.skills.defillama.volumes.fetch_dex_overview import (
+    DefiLlamaFetchDexOverview,
+)
+from intentkit.skills.defillama.volumes.fetch_dex_summary import (
+    DefiLlamaFetchDexSummary,
+)
+from intentkit.skills.defillama.volumes.fetch_options_overview import (
+    DefiLlamaFetchOptionsOverview,
+)
+from intentkit.skills.defillama.yields.fetch_pool_chart import DefiLlamaFetchPoolChart
+
+# Yields Tools
+from intentkit.skills.defillama.yields.fetch_pools import DefiLlamaFetchPools
+
+# we cache skills in system level, because they are stateless
+_cache: dict[str, DefiLlamaBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    # TVL Skills
+    fetch_protocols: SkillState
+    fetch_protocol: SkillState
+    fetch_historical_tvl: SkillState
+    fetch_chain_historical_tvl: SkillState
+    fetch_protocol_current_tvl: SkillState
+    fetch_chains: SkillState
+
+    # Coins Skills
+    fetch_current_prices: SkillState
+    fetch_historical_prices: SkillState
+    fetch_batch_historical_prices: SkillState
+    fetch_price_chart: SkillState
+    fetch_price_percentage: SkillState
+    fetch_first_price: SkillState
+    fetch_block: SkillState
+
+    # Stablecoins Skills
+    fetch_stablecoins: SkillState
+    fetch_stablecoin_charts: SkillState
+    fetch_stablecoin_chains: SkillState
+    fetch_stablecoin_prices: SkillState
+
+    # Yields Skills
+    fetch_pools: SkillState
+    fetch_pool_chart: SkillState
+
+    # Volumes Skills
+    fetch_dex_overview: SkillState
+    fetch_dex_summary: SkillState
+    fetch_options_overview: SkillState
+
+    # Fees Skills
+    fetch_fees_overview: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for DeFi Llama skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[DefiLlamaBaseTool]:
+    """Get all DeFi Llama skills."""
+    available_skills = []
+
+    # Include skills based on their state
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_defillama_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_defillama_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> DefiLlamaBaseTool:
+    """Get a DeFi Llama skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested DeFi Llama skill
+
+    Notes:
+        Each skill maps to a specific DeFi Llama API endpoint. Some skills handle both
+        base and chain-specific endpoints through optional parameters rather than
+        separate implementations.
+    """
+    # TVL Skills
+    if name == "fetch_protocols":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchProtocols(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_protocol":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchProtocol(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_historical_tvl":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchHistoricalTvl(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_chain_historical_tvl":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchChainHistoricalTvl(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_protocol_current_tvl":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchProtocolCurrentTvl(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_chains":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchChains(
+                skill_store=store,
+            )
+        return _cache[name]
+
+    # Coins Skills
+    elif name == "fetch_current_prices":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchCurrentPrices(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_historical_prices":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchHistoricalPrices(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_batch_historical_prices":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchBatchHistoricalPrices(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_price_chart":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchPriceChart(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_price_percentage":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchPricePercentage(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_first_price":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchFirstPrice(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_block":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchBlock(
+                skill_store=store,
+            )
+        return _cache[name]
+
+    # Stablecoins Skills
+    elif name == "fetch_stablecoins":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchStablecoins(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_stablecoin_charts":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchStablecoinCharts(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_stablecoin_chains":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchStablecoinChains(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_stablecoin_prices":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchStablecoinPrices(
+                skill_store=store,
+            )
+        return _cache[name]
+
+    # Yields Skills
+    elif name == "fetch_pools":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchPools(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_pool_chart":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchPoolChart(
+                skill_store=store,
+            )
+        return _cache[name]
+
+    # Volumes Skills
+    elif name == "fetch_dex_overview":  # Handles both base and chain-specific overviews
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchDexOverview(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_dex_summary":
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchDexSummary(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif (
+        name == "fetch_options_overview"
+    ):  # Handles both base and chain-specific overviews
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchOptionsOverview(
+                skill_store=store,
+            )
+        return _cache[name]
+
+    # Fees Skills
+    elif (
+        name == "fetch_fees_overview"
+    ):  # Handles both base and chain-specific overviews
+        if name not in _cache:
+            _cache[name] = DefiLlamaFetchFeesOverview(
+                skill_store=store,
+            )
+        return _cache[name]
+
+    else:
+        logger.warning(f"Unknown DeFi Llama skill: {name}")
+        return None

intentkit/skills/defillama/api.py

@@ -0,0 +1,315 @@
+"""DeFi Llama API implementation and shared schemas."""
+
+from datetime import datetime
+from typing import List, Optional
+
+import httpx
+
+DEFILLAMA_TVL_BASE_URL = "https://api.llama.fi"
+DEFILLAMA_COINS_BASE_URL = "https://coins.llama.fi"
+DEFILLAMA_STABLECOINS_BASE_URL = "https://stablecoins.llama.fi"
+DEFILLAMA_YIELDS_BASE_URL = "https://yields.llama.fi"
+DEFILLAMA_VOLUMES_BASE_URL = "https://api.llama.fi"
+DEFILLAMA_FEES_BASE_URL = "https://api.llama.fi"
+
+
+# TVL API Functions
+async def fetch_protocols() -> dict:
+    """List all protocols on defillama along with their TVL."""
+    url = f"{DEFILLAMA_TVL_BASE_URL}/protocols"
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_protocol(protocol: str) -> dict:
+    """Get historical TVL of a protocol and breakdowns by token and chain."""
+    url = f"{DEFILLAMA_TVL_BASE_URL}/protocol/{protocol}"
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_historical_tvl() -> dict:
+    """Get historical TVL of DeFi on all chains."""
+    url = f"{DEFILLAMA_TVL_BASE_URL}/v2/historicalChainTvl"
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_chain_historical_tvl(chain: str) -> dict:
+    """Get historical TVL of a specific chain."""
+    url = f"{DEFILLAMA_TVL_BASE_URL}/v2/historicalChainTvl/{chain}"
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_protocol_current_tvl(protocol: str) -> dict:
+    """Get current TVL of a protocol."""
+    url = f"{DEFILLAMA_TVL_BASE_URL}/tvl/{protocol}"
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_chains() -> dict:
+    """Get current TVL of all chains."""
+    url = f"{DEFILLAMA_TVL_BASE_URL}/v2/chains"
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+# Coins API Functions
+async def fetch_current_prices(coins: List[str]) -> dict:
+    """Get current prices of tokens by contract address using a 4-hour search window."""
+    coins_str = ",".join(coins)
+    url = f"{DEFILLAMA_COINS_BASE_URL}/prices/current/{coins_str}?searchWidth=4h"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_historical_prices(timestamp: int, coins: List[str]) -> dict:
+    """Get historical prices of tokens by contract address using a 4-hour search window."""
+    coins_str = ",".join(coins)
+    url = f"{DEFILLAMA_COINS_BASE_URL}/prices/historical/{timestamp}/{coins_str}?searchWidth=4h"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_batch_historical_prices(coins_timestamps: dict) -> dict:
+    """Get historical prices for multiple tokens at multiple timestamps."""
+    url = f"{DEFILLAMA_COINS_BASE_URL}/batchHistorical"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(
+            url, params={"coins": coins_timestamps, "searchWidth": "600"}
+        )
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_price_chart(coins: List[str]) -> dict:
+    """Get historical price chart data from the past day for multiple tokens."""
+    coins_str = ",".join(coins)
+    start_time = int(datetime.now().timestamp()) - 86400  # now - 1 day
+
+    url = f"{DEFILLAMA_COINS_BASE_URL}/chart/{coins_str}"
+    params = {"start": start_time, "span": 10, "period": "2d", "searchWidth": "600"}
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_price_percentage(coins: List[str]) -> dict:
+    """Get price percentage changes for multiple tokens over a 24h period."""
+    coins_str = ",".join(coins)
+    current_timestamp = int(datetime.now().timestamp())
+
+    url = f"{DEFILLAMA_COINS_BASE_URL}/percentage/{coins_str}"
+    params = {"timestamp": current_timestamp, "lookForward": "false", "period": "24h"}
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_first_price(coins: List[str]) -> dict:
+    """Get first recorded price data for multiple tokens."""
+    coins_str = ",".join(coins)
+    url = f"{DEFILLAMA_COINS_BASE_URL}/prices/first/{coins_str}"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_block(chain: str) -> dict:
+    """Get current block data for a specific chain."""
+    current_timestamp = int(datetime.now().timestamp())
+    url = f"{DEFILLAMA_COINS_BASE_URL}/block/{chain}/{current_timestamp}"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+# Stablecoins API Functions
+async def fetch_stablecoins() -> dict:
+    """Get comprehensive stablecoin data from DeFi Llama."""
+    url = f"{DEFILLAMA_STABLECOINS_BASE_URL}/stablecoins"
+    params = {"includePrices": "true"}
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_stablecoin_charts(
+    stablecoin_id: str, chain: Optional[str] = None
+) -> dict:
+    """Get historical circulating supply data for a stablecoin."""
+    base_url = f"{DEFILLAMA_STABLECOINS_BASE_URL}/stablecoincharts"
+
+    # If chain is specified, fetch chain-specific data, otherwise fetch all chains
+    endpoint = f"/{chain}" if chain else "/all"
+    url = f"{base_url}{endpoint}?stablecoin={stablecoin_id}"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_stablecoin_chains() -> dict:
+    """Get stablecoin distribution data across all chains."""
+    url = f"{DEFILLAMA_STABLECOINS_BASE_URL}/stablecoinchains"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_stablecoin_prices() -> dict:
+    """Get current stablecoin price data.
+
+    Returns:
+        Dictionary containing stablecoin prices with their dates
+    """
+    url = f"{DEFILLAMA_STABLECOINS_BASE_URL}/stablecoinprices"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+# Yields API Functions
+async def fetch_pools() -> dict:
+    """Get comprehensive data for all yield-generating pools."""
+    url = f"{DEFILLAMA_YIELDS_BASE_URL}/pools"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_pool_chart(pool_id: str) -> dict:
+    """Get historical chart data for a specific pool."""
+    url = f"{DEFILLAMA_YIELDS_BASE_URL}/chart/{pool_id}"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+# Volumes API Functions
+async def fetch_dex_overview() -> dict:
+    """Get overview data for DEX protocols."""
+    url = f"{DEFILLAMA_VOLUMES_BASE_URL}/overview/dexs"
+    params = {
+        "excludeTotalDataChart": "true",
+        "excludeTotalDataChartBreakdown": "true",
+        "dataType": "dailyVolume",
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_dex_summary(protocol: str) -> dict:
+    """Get summary data for a specific DEX protocol."""
+    url = f"{DEFILLAMA_VOLUMES_BASE_URL}/summary/dexs/{protocol}"
+    params = {
+        "excludeTotalDataChart": "true",
+        "excludeTotalDataChartBreakdown": "true",
+        "dataType": "dailyVolume",
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_options_overview() -> dict:
+    """Get overview data for options protocols from DeFi Llama."""
+    url = f"{DEFILLAMA_VOLUMES_BASE_URL}/overview/options"
+    params = {
+        "excludeTotalDataChart": "true",
+        "excludeTotalDataChartBreakdown": "true",
+        "dataType": "dailyPremiumVolume",
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+# Fees and Revenue API Functions
+async def fetch_fees_overview() -> dict:
+    """Get overview data for fees from DeFi Llama.
+
+    Returns:
+        Dictionary containing fees overview data
+    """
+    url = f"{DEFILLAMA_FEES_BASE_URL}/overview/fees"
+    params = {
+        "excludeTotalDataChart": "true",
+        "excludeTotalDataChartBreakdown": "true",
+        "dataType": "dailyFees",
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()