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

intentkit/skills/defillama/stablecoins/fetch_stablecoin_charts.py

@@ -0,0 +1,129 @@
+"""Tool for fetching stablecoin charts via DeFi Llama API."""
+
+from typing import List, Optional, Type
+
+from langchain.schema.runnable import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.defillama.api import fetch_stablecoin_charts
+from intentkit.skills.defillama.base import DefiLlamaBaseTool
+
+FETCH_STABLECOIN_CHARTS_PROMPT = """
+This tool fetches historical circulating supply data from DeFi Llama for a specific stablecoin.
+Required:
+- Stablecoin ID
+Optional:
+- Chain name for chain-specific data
+Returns historical data including:
+- Total circulating supply
+- Circulating supply in USD
+- Daily data points
+"""
+
+
+class CirculatingSupply(BaseModel):
+    """Model representing circulating supply amounts."""
+
+    peggedUSD: float = Field(..., description="Amount pegged to USD")
+
+
+class StablecoinDataPoint(BaseModel):
+    """Model representing a single historical data point."""
+
+    date: str = Field(..., description="Unix timestamp of the data point")
+    totalCirculating: CirculatingSupply = Field(
+        ..., description="Total circulating supply"
+    )
+    totalCirculatingUSD: CirculatingSupply = Field(
+        ..., description="Total circulating supply in USD"
+    )
+
+
+class FetchStablecoinChartsInput(BaseModel):
+    """Input schema for fetching stablecoin chart data."""
+
+    stablecoin_id: str = Field(
+        ..., description="ID of the stablecoin to fetch data for"
+    )
+    chain: Optional[str] = Field(
+        None, description="Optional chain name for chain-specific data"
+    )
+
+
+class FetchStablecoinChartsResponse(BaseModel):
+    """Response schema for stablecoin chart data."""
+
+    data: List[StablecoinDataPoint] = Field(
+        default_factory=list, description="List of historical data points"
+    )
+    chain: Optional[str] = Field(
+        None, description="Chain name if chain-specific data was requested"
+    )
+    error: Optional[str] = Field(None, description="Error message if any")
+
+
+class DefiLlamaFetchStablecoinCharts(DefiLlamaBaseTool):
+    """Tool for fetching stablecoin chart data from DeFi Llama.
+
+    This tool retrieves historical circulating supply data for a specific stablecoin,
+    optionally filtered by chain.
+
+    Example:
+        charts_tool = DefiLlamaFetchStablecoinCharts(
+            skill_store=store,
+            agent_id="agent_123",
+            agent_store=agent_store
+        )
+        # Get all chains data
+        result = await charts_tool._arun(stablecoin_id="1")
+        # Get chain-specific data
+        result = await charts_tool._arun(stablecoin_id="1", chain="ethereum")
+    """
+
+    name: str = "defillama_fetch_stablecoin_charts"
+    description: str = FETCH_STABLECOIN_CHARTS_PROMPT
+    args_schema: Type[BaseModel] = FetchStablecoinChartsInput
+
+    async def _arun(
+        self, config: RunnableConfig, stablecoin_id: str, chain: Optional[str] = None
+    ) -> FetchStablecoinChartsResponse:
+        """Fetch historical chart data for the given stablecoin.
+
+        Args:
+            config: Runnable configuration
+            stablecoin_id: ID of the stablecoin to fetch data for
+            chain: Optional chain name for chain-specific data
+
+        Returns:
+            FetchStablecoinChartsResponse containing historical data or error
+        """
+        try:
+            # Validate chain if provided
+            if chain:
+                is_valid, normalized_chain = await self.validate_chain(chain)
+                if not is_valid:
+                    return FetchStablecoinChartsResponse(
+                        error=f"Invalid chain: {chain}"
+                    )
+                chain = normalized_chain
+
+            # Check rate limiting
+            context = self.context_from_config(config)
+            is_rate_limited, error_msg = await self.check_rate_limit(context)
+            if is_rate_limited:
+                return FetchStablecoinChartsResponse(error=error_msg)
+
+            # Fetch chart data from API
+            result = await fetch_stablecoin_charts(
+                stablecoin_id=stablecoin_id, chain=chain
+            )
+
+            # Check for API errors
+            if isinstance(result, dict) and "error" in result:
+                return FetchStablecoinChartsResponse(error=result["error"])
+
+            # Parse response data
+            return FetchStablecoinChartsResponse(data=result, chain=chain)
+
+        except Exception as e:
+            return FetchStablecoinChartsResponse(error=str(e))

intentkit/skills/defillama/stablecoins/fetch_stablecoin_prices.py

@@ -0,0 +1,83 @@
+"""Tool for fetching stablecoin prices via DeFi Llama API."""
+
+from typing import Dict, List, Optional
+
+from langchain.schema.runnable import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.defillama.api import fetch_stablecoin_prices
+from intentkit.skills.defillama.base import DefiLlamaBaseTool
+
+FETCH_STABLECOIN_PRICES_PROMPT = """
+This tool fetches current price data for stablecoins from DeFi Llama.
+Returns:
+- Historical price points with timestamps
+- Current prices for each stablecoin
+- Prices indexed by stablecoin identifier
+"""
+
+
+class PriceDataPoint(BaseModel):
+    """Model representing a price data point."""
+
+    date: str = Field(..., description="Unix timestamp for the price data")
+    prices: Dict[str, float] = Field(
+        ..., description="Dictionary of stablecoin prices indexed by identifier"
+    )
+
+
+class FetchStablecoinPricesResponse(BaseModel):
+    """Response schema for stablecoin prices data."""
+
+    data: List[PriceDataPoint] = Field(
+        default_factory=list, description="List of price data points"
+    )
+    error: Optional[str] = Field(None, description="Error message if any")
+
+
+class DefiLlamaFetchStablecoinPrices(DefiLlamaBaseTool):
+    """Tool for fetching stablecoin prices from DeFi Llama.
+
+    This tool retrieves current price data for stablecoins, including historical
+    price points and their timestamps.
+
+    Example:
+        prices_tool = DefiLlamaFetchStablecoinPrices(
+            skill_store=store,
+            agent_id="agent_123",
+            agent_store=agent_store
+        )
+        result = await prices_tool._arun()
+    """
+
+    name: str = "defillama_fetch_stablecoin_prices"
+    description: str = FETCH_STABLECOIN_PRICES_PROMPT
+    args_schema: None = None  # No input parameters needed
+
+    async def _arun(self, config: RunnableConfig) -> FetchStablecoinPricesResponse:
+        """Fetch stablecoin price data.
+
+        Returns:
+            FetchStablecoinPricesResponse containing price data or error
+        """
+        try:
+            # Check rate limiting
+            context = self.context_from_config(config)
+            is_rate_limited, error_msg = await self.check_rate_limit(context)
+            if is_rate_limited:
+                return FetchStablecoinPricesResponse(error=error_msg)
+
+            # Fetch price data from API
+            result = await fetch_stablecoin_prices()
+
+            # Check for API errors
+            if isinstance(result, dict) and "error" in result:
+                return FetchStablecoinPricesResponse(error=result["error"])
+
+            # Parse results into models
+            data_points = [PriceDataPoint(**point) for point in result]
+
+            return FetchStablecoinPricesResponse(data=data_points)
+
+        except Exception as e:
+            return FetchStablecoinPricesResponse(error=str(e))

intentkit/skills/defillama/stablecoins/fetch_stablecoins.py

@@ -0,0 +1,126 @@
+"""Tool for fetching stablecoin data via DeFi Llama API."""
+
+from typing import Dict, List, Optional
+
+from langchain.schema.runnable import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.defillama.api import fetch_stablecoins
+from intentkit.skills.defillama.base import DefiLlamaBaseTool
+
+FETCH_STABLECOINS_PROMPT = """
+This tool fetches comprehensive stablecoin data from DeFi Llama.
+Returns:
+- List of stablecoins with details like name, symbol, market cap
+- Per-chain circulating amounts
+- Historical circulating amounts (day/week/month)
+- Current prices and price history
+- Peg mechanism and type information
+"""
+
+
+class CirculatingAmount(BaseModel):
+    """Model representing circulating amounts for a specific peg type."""
+
+    peggedUSD: float = Field(..., description="Amount pegged to USD")
+
+
+class ChainCirculating(BaseModel):
+    """Model representing circulating amounts on a specific chain."""
+
+    current: CirculatingAmount = Field(..., description="Current circulating amount")
+    circulatingPrevDay: CirculatingAmount = Field(
+        ..., description="Circulating amount from previous day"
+    )
+    circulatingPrevWeek: CirculatingAmount = Field(
+        ..., description="Circulating amount from previous week"
+    )
+    circulatingPrevMonth: CirculatingAmount = Field(
+        ..., description="Circulating amount from previous month"
+    )
+
+
+class Stablecoin(BaseModel):
+    """Model representing a single stablecoin's data."""
+
+    id: str = Field(..., description="Unique identifier")
+    name: str = Field(..., description="Stablecoin name")
+    symbol: str = Field(..., description="Token symbol")
+    gecko_id: Optional[str] = Field(None, description="CoinGecko ID if available")
+    pegType: str = Field(..., description="Type of peg (e.g. peggedUSD)")
+    priceSource: str = Field(..., description="Source of price data")
+    pegMechanism: str = Field(..., description="Mechanism maintaining the peg")
+    circulating: CirculatingAmount = Field(
+        ..., description="Current total circulating amount"
+    )
+    circulatingPrevDay: CirculatingAmount = Field(
+        ..., description="Total circulating amount from previous day"
+    )
+    circulatingPrevWeek: CirculatingAmount = Field(
+        ..., description="Total circulating amount from previous week"
+    )
+    circulatingPrevMonth: CirculatingAmount = Field(
+        ..., description="Total circulating amount from previous month"
+    )
+    chainCirculating: Dict[str, ChainCirculating] = Field(
+        ..., description="Circulating amounts per chain"
+    )
+    chains: List[str] = Field(
+        ..., description="List of chains where the stablecoin is present"
+    )
+    price: float = Field(..., description="Current price in USD")
+
+
+class FetchStablecoinsResponse(BaseModel):
+    """Response schema for stablecoin data."""
+
+    peggedAssets: List[Stablecoin] = Field(
+        default_factory=list, description="List of stablecoins with their data"
+    )
+    error: Optional[str] = Field(None, description="Error message if any")
+
+
+class DefiLlamaFetchStablecoins(DefiLlamaBaseTool):
+    """Tool for fetching stablecoin data from DeFi Llama.
+
+    This tool retrieves comprehensive data about stablecoins, including their
+    circulating supply across different chains, price information, and peg details.
+
+    Example:
+        stablecoins_tool = DefiLlamaFetchStablecoins(
+            skill_store=store,
+            agent_id="agent_123",
+            agent_store=agent_store
+        )
+        result = await stablecoins_tool._arun()
+    """
+
+    name: str = "defillama_fetch_stablecoins"
+    description: str = FETCH_STABLECOINS_PROMPT
+    args_schema: None = None  # No input parameters needed
+
+    async def _arun(self, config: RunnableConfig) -> FetchStablecoinsResponse:
+        """Fetch stablecoin data.
+
+        Returns:
+            FetchStablecoinsResponse containing stablecoin data or error
+        """
+        try:
+            # Check rate limiting
+            context = self.context_from_config(config)
+            is_rate_limited, error_msg = await self.check_rate_limit(context)
+            if is_rate_limited:
+                return FetchStablecoinsResponse(error=error_msg)
+
+            # Fetch stablecoin data from API
+            result = await fetch_stablecoins()
+
+            # Check for API errors
+            if isinstance(result, dict) and "error" in result:
+                return FetchStablecoinsResponse(error=result["error"])
+
+            # Return the response matching the API structure
+            return FetchStablecoinsResponse(**result)
+
+        except Exception as e:
+            return FetchStablecoinsResponse(error=str(e))

intentkit/skills/defillama/tests/api_integration.test.py

@@ -0,0 +1,192 @@
+import asyncio
+import logging
+import unittest
+from datetime import datetime, timedelta
+from unittest.runner import TextTestResult
+
+# Import all functions from your API module
+from intentkit.skills.defillama.api import (
+    fetch_chains,
+    fetch_current_prices,
+    fetch_dex_overview,
+    fetch_dex_summary,
+    fetch_fees_overview,
+    fetch_historical_prices,
+    fetch_historical_tvl,
+    fetch_price_chart,
+    fetch_protocol,
+    fetch_protocols,
+    fetch_stablecoin_chains,
+    fetch_stablecoin_prices,
+    fetch_stablecoins,
+)
+
+# Configure logging to only show warnings and errors
+logging.basicConfig(level=logging.WARNING)
+
+
+class QuietTestResult(TextTestResult):
+    """Custom TestResult class that minimizes output unless there's a failure"""
+
+    def startTest(self, test):
+        self._started_at = datetime.now()
+        super().startTest(test)
+
+    def addSuccess(self, test):
+        super().addSuccess(test)
+        if self.showAll:
+            self.stream.write("")
+            self.stream.flush()
+
+    def addError(self, test, err):
+        super().addError(test, err)
+        self.stream.write("\n")
+        self.stream.write(self.separator1 + "\n")
+        self.stream.write(f"ERROR: {self.getDescription(test)}\n")
+        self.stream.write(self.separator2 + "\n")
+        self.stream.write(self._exc_info_to_string(err, test))
+        self.stream.write("\n")
+        self.stream.flush()
+
+    def addFailure(self, test, err):
+        super().addFailure(test, err)
+        self.stream.write("\n")
+        self.stream.write(self.separator1 + "\n")
+        self.stream.write(f"FAIL: {self.getDescription(test)}\n")
+        self.stream.write(self.separator2 + "\n")
+        self.stream.write(self._exc_info_to_string(err, test))
+        self.stream.write("\n")
+        self.stream.flush()
+
+
+class QuietTestRunner(unittest.TextTestRunner):
+    """Custom TestRunner that uses QuietTestResult"""
+
+    resultclass = QuietTestResult
+
+
+class TestDefiLlamaAPI(unittest.TestCase):
+    """Integration tests for DeFi Llama API client"""
+
+    def setUp(self):
+        """Set up the async event loop"""
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+        self.timeout = 3000
+
+    def tearDown(self):
+        """Clean up the event loop"""
+        self.loop.close()
+
+    def run_async(self, coro):
+        """Helper to run async functions in test methods with timeout"""
+        try:
+            return self.loop.run_until_complete(
+                asyncio.wait_for(coro, timeout=self.timeout)
+            )
+        except asyncio.TimeoutError:
+            raise AssertionError(f"Test timed out after {self.timeout} seconds")
+        except Exception as e:
+            raise AssertionError(f"Test failed with exception: {str(e)}")
+
+    def assert_successful_response(self, response):
+        """Helper to check if response contains an error"""
+        if isinstance(response, dict) and "error" in response:
+            raise AssertionError(f"API request failed: {response['error']}")
+
+    def test_tvl_endpoints(self):
+        """Test TVL-related endpoints"""
+        # Test fetch_protocols
+        protocols = self.run_async(fetch_protocols())
+        self.assert_successful_response(protocols)
+        self.assertIsInstance(protocols, list)
+        if len(protocols) > 0:
+            self.assertIn("tvl", protocols[0])
+
+        # Test fetch_protocol using Aave as an example
+        protocol_data = self.run_async(fetch_protocol("aave"))
+        self.assert_successful_response(protocol_data)
+        self.assertIsInstance(protocol_data, dict)
+
+        # Test fetch_historical_tvl
+        historical_tvl = self.run_async(fetch_historical_tvl())
+        self.assert_successful_response(historical_tvl)
+        self.assertIsInstance(historical_tvl, list)
+        # Verify the structure of historical TVL data points
+        if len(historical_tvl) > 0:
+            self.assertIn("date", historical_tvl[0])
+            self.assertIn("tvl", historical_tvl[0])
+
+        # Test fetch_chains
+        chains = self.run_async(fetch_chains())
+        self.assert_successful_response(chains)
+        self.assertIsInstance(chains, list)
+
+    def test_coins_endpoints(self):
+        """Test coin price-related endpoints"""
+        test_coins = ["ethereum:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"]
+
+        # Test fetch_current_prices
+        current_prices = self.run_async(fetch_current_prices(test_coins))
+        self.assert_successful_response(current_prices)
+        self.assertIsInstance(current_prices, dict)
+
+        # Test fetch_historical_prices
+        timestamp = int((datetime.now() - timedelta(days=1)).timestamp())
+        historical_prices = self.run_async(
+            fetch_historical_prices(timestamp, test_coins)
+        )
+        self.assert_successful_response(historical_prices)
+        self.assertIsInstance(historical_prices, dict)
+
+        # Test fetch_price_chart
+        price_chart = self.run_async(fetch_price_chart(test_coins))
+        self.assert_successful_response(price_chart)
+        self.assertIsInstance(price_chart, dict)
+        self.assertIn("coins", price_chart)
+        # Verify the structure of the response
+        coin_data = price_chart["coins"].get(test_coins[0])
+        self.assertIsNotNone(coin_data)
+        self.assertIn("prices", coin_data)
+        self.assertIsInstance(coin_data["prices"], list)
+
+    def test_stablecoin_endpoints(self):
+        """Test stablecoin-related endpoints"""
+        # Test fetch_stablecoins
+        stablecoins = self.run_async(fetch_stablecoins())
+        self.assert_successful_response(stablecoins)
+        self.assertIsInstance(stablecoins, dict)
+
+        # Test fetch_stablecoin_chains
+        chains = self.run_async(fetch_stablecoin_chains())
+        self.assert_successful_response(chains)
+        self.assertIsInstance(chains, list)
+
+        # Test fetch_stablecoin_prices
+        prices = self.run_async(fetch_stablecoin_prices())
+        self.assert_successful_response(prices)
+        self.assertIsInstance(prices, list)
+
+    def test_volume_endpoints(self):
+        """Test volume-related endpoints"""
+        # Test fetch_dex_overview
+        dex_overview = self.run_async(fetch_dex_overview())
+        self.assert_successful_response(dex_overview)
+        self.assertIsInstance(dex_overview, dict)
+
+        # Test fetch_dex_summary using Uniswap as example
+        dex_summary = self.run_async(fetch_dex_summary("uniswap"))
+        self.assert_successful_response(dex_summary)
+        self.assertIsInstance(dex_summary, dict)
+
+    def test_fees_endpoint(self):
+        """Test fees endpoint"""
+        fees_overview = self.run_async(fetch_fees_overview())
+        self.assert_successful_response(fees_overview)
+        self.assertIsInstance(fees_overview, dict)
+
+
+if __name__ == "__main__":
+    # Use the quiet test runner
+    runner = QuietTestRunner(verbosity=1)
+    unittest.main(testRunner=runner)