semvec/pypi-packages huggingface dataset:
goat-sdk-wallet-evm 0.1.2
Goat SDK EVM wallet implementation
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai, evm, wallet

# EVM Wallet for GOAT SDK

A Python implementation of an EVM wallet for the GOAT SDK, providing secure key management and transaction signing capabilities for Ethereum Virtual Machine compatible networks.

## Installation

```bash
poetry add goat-sdk-wallet-evm
```

## Usage

```python
from goat_wallets.evm import evm_wallet

# Initialize wallet with private key
wallet = evm_wallet(
    private_key="${WALLET_PRIVATE_KEY}",  # Your EVM wallet private key
    rpc_url="${RPC_PROVIDER_URL}"  # Your EVM RPC endpoint
)

# Get wallet address
address = wallet.get_address()

# Get ETH balance
balance = await wallet.get_balance()

# Sign and send transaction
tx_hash = await wallet.sign_and_send_transaction({
    "to": "recipient_address",
    "value": "1000000000000000000",  # 1 ETH in wei
    "data": "0x",  # Optional contract data
})

# Get transaction receipt
receipt = await wallet.get_transaction_receipt(tx_hash)
```

## Features

- Secure Key Management:
  - Private key support
  - Public address derivation
  - Message signing
  
- Transaction Operations:
  - Transaction signing
  - Transaction sending
  - Gas estimation
  - Receipt tracking
  
- Balance Management:
  - Native token balance
  - ERC20 token balance
  - Contract interactions
  
- Network Support:
  - Ethereum
  - Polygon
  - Arbitrum
  - Optimism
  - Base
  - BNB Chain
  - All EVM-compatible chains

## License

This project is licensed under the terms of the MIT license.
goat-sdk-plugin-uniswap 0.1.2
Goat plugin for uniswap
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, agents, ai, uniswap

# Uniswap Plugin for GOAT SDK

A plugin for the GOAT SDK that provides Uniswap DEX functionality for token swaps and liquidity operations.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-uniswap

# Install required dependencies
poetry add goat-sdk-wallet-evm
poetry add goat-sdk-plugin-erc20
```

## Usage

```python
from goat_plugins.uniswap import uniswap, UniswapPluginOptions

# Initialize the plugin
options = UniswapPluginOptions(
    api_key="${UNISWAP_API_KEY}",  # Optional: API key for higher rate limits
    rpc_url="${RPC_PROVIDER_URL}"   # Your EVM RPC provider URL
)
plugin = uniswap(options)

# Get token price
price = await plugin.get_token_price(
    token_address="0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
    chain_id=1  # Ethereum mainnet
)

# Get swap quote
quote = await plugin.get_swap_quote(
    chain_id=1,
    token_in="0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",   # WETH
    token_out="0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
    amount="1000000000000000000",  # 1 WETH in wei
    slippage=50  # 0.5% slippage tolerance
)
```

## Features

- Token price discovery
- Swap quote generation
- Token swap execution
- Liquidity pool information
- Position management
- Supported chains:
  - Ethereum
  - Polygon
  - Arbitrum
  - Optimism
  - Base
  - All Uniswap v3 supported networks

## License

This project is licensed under the terms of the MIT license.
goat-sdk-plugin-superfluid 0.1.1
Goat plugin for Superfluid
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai

# Superfluid Plugin for GOAT SDK

A plugin for the GOAT SDK that provides real-time token streaming and programmable cashflow functionality through the Superfluid Protocol.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-superfluid

# Install required wallet dependency
poetry add goat-sdk-wallet-evm
```

## Usage

```python
from goat_plugins.superfluid import superfluid, SuperfluidPluginOptions

# Initialize the plugin
options = SuperfluidPluginOptions(
    rpc_url="${RPC_PROVIDER_URL}"  # Your EVM RPC URL
)
plugin = superfluid(options)

# Create a token stream
stream = await plugin.create_stream(
    chain_id=137,  # Polygon
    token_address="0xCAa7349CEA390F89641fe306D93591f87595dc1F",  # USDC.e
    recipient="recipient_address",
    flow_rate="385802469135802",  # 1000 tokens per month
)

# Get stream details
flow_info = await plugin.get_flow(
    chain_id=137,
    token_address="0xCAa7349CEA390F89641fe306D93591f87595dc1F",
    sender="sender_address",
    recipient="recipient_address"
)

# Manage index subscription
subscription = await plugin.update_subscription(
    chain_id=137,
    token_address="0xCAa7349CEA390F89641fe306D93591f87595dc1F",
    publisher="publisher_address",
    index_id=1,
    units=100
)
```

## Features

- Token Streaming:
  - Create and manage token streams
  - Real-time balance updates
  - Flow rate calculations
  - Stream statistics
  
- Pool Management:
  - Instant Distribution Agreements (IDA)
  - Pool membership control
  - Units management
  - Distribution calculations
  
- Advanced Features:
  - Super Agreements
  - Super Tokens
  - Batch call support
  - Stream automation
  
- Supported Networks:
  - Ethereum
  - Polygon
  - Arbitrum
  - Optimism
  - Avalanche
  - BSC
  - Base
  - All Superfluid-enabled chains

## License

This project is licensed under the terms of the MIT license.
goat-sdk-plugin-opensea 0.1.1
Goat plugin for OpenSea
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai, nft, opensea

# OpenSea Plugin for GOAT SDK

A plugin for the GOAT SDK that provides OpenSea NFT marketplace functionality for querying NFT collections, sales, and metadata.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-opensea

# Install required wallet dependency
poetry add goat-sdk-wallet-evm
```

## Usage

```python
from goat_plugins.opensea import opensea, OpenSeaPluginOptions

# Initialize the plugin
options = OpenSeaPluginOptions(
    api_key="${ETHERSCAN_API}"  # Your OpenSea API key
)
plugin = opensea(options)

# Get NFT collection statistics
stats = await plugin.get_nft_collection_statistics(
    collection_slug="doodles-official",  # Example collection
    chain="ethereum"  # Specify the chain
)

# Get recent NFT sales
sales = await plugin.get_nft_sales(
    collection_slug="doodles-official",
    chain="ethereum",
    limit=10  # Number of recent sales to fetch
)

# Get NFT metadata
metadata = await plugin.get_nft_metadata(
    contract_address="0x8a90CAb2b38dba80c64b7734e58Ee1dB38B8992e",  # Doodles contract
    token_id="1234",
    chain="ethereum"
)
```

## Features

- NFT collection statistics
- Recent sales tracking
- NFT metadata retrieval
- Collection floor price tracking
- Supported chains:
  - Ethereum
  - Polygon
  - Arbitrum
  - Optimism
  - Base
  - All OpenSea-supported EVM chains

## License

This project is licensed under the terms of the MIT license.
goat-sdk-plugin-nansen 0.1.1
Nansen plugin for GOAT SDK
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai, nansen

# Nansen Plugin for GOAT SDK

A plugin for the GOAT SDK that provides access to Nansen's on-chain analytics and data services across multiple blockchains.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-nansen

# Install required wallet dependencies
poetry add goat-sdk-wallet-evm
poetry add goat-sdk-wallet-solana
```

## Usage

```python
from goat_plugins.nansen import nansen, NansenPluginOptions

# Initialize the plugin
options = NansenPluginOptions(
    api_key="${COINMARKETCAP_API}"  # Your Nansen API key
)
plugin = nansen(options)

# Get token analytics
token_data = await plugin.get_token_analytics(
    token_address="0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
    chain="ethereum"
)

# Get NFT collection analytics
nft_data = await plugin.get_nft_collection_analytics(
    collection_address="0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D",  # BAYC
    chain="ethereum",
    time_range="24h"
)

# Get smart money flows
smart_money = await plugin.get_smart_money_flows(
    token_address="0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
    chain="ethereum",
    wallet_labels=["smart_money", "institutions"]
)
```

## Features

- Token Analytics:
  - Historical price and volume data
  - Token holder analysis
  - Smart money flow tracking
  - Trading activity metrics
  
- NFT Analytics:
  - Collection statistics
  - Floor price tracking
  - Holder distribution
  - Trading volume analysis
  
- Smart Money Tracking:
  - Wallet labeling and categorization
  - Token flow analysis
  - Smart money movement alerts
  - Institution tracking
  
- Supported Chains:
  - Ethereum
  - Polygon
  - BNB Chain
  - Arbitrum
  - Optimism
  - Avalanche
  - Solana
  - Base

## License

This project is licensed under the terms of the MIT license.
goat-sdk-plugin-jsonrpc 0.1.2
Goat plugin for JSON-RPC
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai

# JSON-RPC Plugin for GOAT SDK

A plugin for the GOAT SDK that enables making JSON-RPC calls to any blockchain or protocol endpoint supporting the JSON-RPC 2.0 specification.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-jsonrpc

# Install optional wallet dependencies for chain-specific operations
poetry add goat-sdk-wallet-evm
poetry add goat-sdk-wallet-solana
```

## Usage

```python
from goat_plugins.jsonrpc import jsonrpc, JSONRpcPluginOptions

# Initialize the plugin for EVM chain
evm_options = JSONRpcPluginOptions(
    endpoint="${RPC_PROVIDER_URL}"  # Your EVM RPC endpoint
)
evm_plugin = jsonrpc(evm_options)

# Get latest block number on Ethereum
eth_response = await evm_plugin.call({
    "method": "eth_blockNumber",
    "params": [],
    "id": 1,
    "jsonrpc": "2.0"
})

# Initialize plugin for Solana
sol_options = JSONRpcPluginOptions(
    endpoint="${RPC_PROVIDER_URL}"  # Your Solana RPC endpoint
)
sol_plugin = jsonrpc(sol_options)

# Get account info on Solana
sol_response = await sol_plugin.call({
    "method": "getAccountInfo",
    "params": [
        "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg",
        {"encoding": "base58"}
    ],
    "id": 1,
    "jsonrpc": "2.0"
})
```

## Features

- Protocol Support:
  - JSON-RPC 2.0 specification
  - WebSocket connections
  - Batch requests
  - Error handling
  
- Chain Compatibility:
  - Ethereum and EVM chains
  - Solana
  - Any JSON-RPC compatible chain
  
- Advanced Features:
  - Async implementation
  - Request retries
  - Rate limiting
  - Response validation
  
- Integration Support:
  - GOAT SDK integration
  - LangChain compatibility
  - Custom middleware support
  - Error event handling

## License

This project is licensed under the terms of the MIT license.
goat-sdk-plugin-farcaster 0.1.2
Goat plugin for Farcaster
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai

# Farcaster Plugin for GOAT SDK

A plugin for the GOAT SDK that provides Farcaster social protocol functionality through the Neynar API.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-farcaster

# Install required wallet dependency
poetry add goat-sdk-wallet-evm
```

## Usage

```python
from goat_plugins.farcaster import farcaster, FarcasterPluginOptions

# Initialize the plugin
options = FarcasterPluginOptions(
    api_key="${ETHERSCAN_API}",  # Your Neynar API key
    base_url="https://api.neynar.com"  # Optional: Custom API base URL
)
plugin = farcaster(options)

# Create a new cast
cast = await plugin.create_cast(
    text="Hello Farcaster! 🐐",
    signer_uuid="your-signer-uuid"
)

# Get user's casts
casts = await plugin.get_user_casts(
    fid=1234,  # Farcaster user ID
    limit=10
)

# Search casts
search_results = await plugin.search_casts(
    query="goat sdk",
    limit=20
)
```

## Features

- Social Protocol Integration:
  - Cast creation and interaction
  - Thread and conversation management
  - User profile management
  - Follow/unfollow functionality
  
- Content Discovery:
  - Cast search and filtering
  - Trending topics
  - User recommendations
  - Channel exploration
  
- Authentication:
  - Signer UUID management
  - Key rotation support
  - Multi-device support
  
- Protocol Features:
  - Reactions and recasts
  - Mentions and notifications
  - Rich media support
  - Channel-based organization
  
- Network Support:
  - Optimism (Layer 2)
  - Farcaster Hub Network

## License

This project is licensed under the terms of the MIT license.
goat-sdk-plugin-dexscreener 0.1.2
Goat plugin for Dexscreener
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai

# DEXScreener Plugin for GOAT SDK

A plugin for the GOAT SDK that provides real-time DEX pair data, price feeds, and liquidity information across multiple blockchain networks through the DEXScreener API.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-dexscreener

# Install optional wallet dependencies for chain-specific operations
poetry add goat-sdk-wallet-evm
poetry add goat-sdk-wallet-solana
```

## Usage

```python
from goat_plugins.dexscreener import dexscreener, DexscreenerPluginOptions

# Initialize the plugin
options = DexscreenerPluginOptions()
plugin = dexscreener(options)

# Get pair data by chain and pair address
eth_pair = await plugin.get_pair(
    chain_id="ethereum",
    pair_address="0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640"  # USDC-ETH
)

# Search for pairs by token address
pairs = await plugin.search_pairs(
    token_address="0x6B175474E89094C44Da98b954EedeAC495271d0F"  # DAI
)

# Get Solana token pairs
sol_pairs = await plugin.get_pairs(
    chain_id="solana",
    token_address="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"  # USDC
)
```

## Features

- DEX Pair Data:
  - Price and volume metrics
  - Liquidity information
  - Trading volume analytics
  - Price change statistics
  
- Search Capabilities:
  - Token address search
  - Pair address lookup
  - Multi-chain queries
  - Real-time updates
  
- Market Analysis:
  - Price trends
  - Volume analysis
  - Liquidity depth
  - Trading patterns
  
- Supported Networks:
  - Ethereum
  - BSC
  - Polygon
  - Arbitrum
  - Optimism
  - Avalanche
  - Solana
  - Base
  - All major DEX-enabled chains

## License

This project is licensed under the terms of the MIT license.
goat-sdk-plugin-coingecko 0.1.2
Goat plugin for Coingecko
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai

# CoinGecko Plugin for GOAT SDK

A plugin for the GOAT SDK that provides comprehensive cryptocurrency market data, price feeds, and analytics through the CoinGecko API.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-coingecko

# Install optional wallet dependencies for chain-specific operations
poetry add goat-sdk-wallet-evm
poetry add goat-sdk-wallet-solana
```

## Usage

```python
from goat_plugins.coingecko import coingecko, CoinGeckoPluginOptions

# Initialize the plugin
options = CoinGeckoPluginOptions(
    api_key="${COINGECKO_API_KEY}"  # Your CoinGecko API key
)
plugin = coingecko(options)

# Get token price data
prices = await plugin.get_token_prices(
    token_ids=["bitcoin", "ethereum"],
    vs_currencies=["usd", "eur"]
)

# Get detailed market data
market_data = await plugin.get_market_data(
    token_id="ethereum",
    include_community_data=True,
    include_developer_data=True
)

# Get historical price data
history = await plugin.get_price_history(
    token_id="bitcoin",
    vs_currency="usd",
    days=30,
    interval="daily"
)
```

## Features

- Market Data:
  - Real-time price feeds
  - Historical price data
  - Volume statistics
  - Market capitalization
  
- Token Analytics:
  - Price change metrics
  - Trading volume analysis
  - Market dominance
  - Supply information
  
- Additional Data:
  - Community metrics
  - Developer activity
  - Social statistics
  - Exchange listings
  
- Supported Features:
  - Multi-currency support
  - Custom time intervals
  - Batch data retrieval
  - Rate limit handling
  
- Market Categories:
  - Cryptocurrencies
  - DeFi tokens
  - NFT projects
  - Exchange tokens
  - Layer 1/2 tokens

## License

This project is licensed under the terms of the MIT license.
goat-sdk-plugin-allora 0.1.1
Goat plugin for Allora Network price predictions
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai, allora, prediction

# Allora Plugin for GOAT SDK

A plugin for the GOAT SDK that provides AI-powered blockchain analytics and predictive modeling capabilities through the Allora API.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-allora

# Install optional wallet dependencies for chain-specific operations
poetry add goat-sdk-wallet-evm
poetry add goat-sdk-wallet-solana
```

## Usage

```python
from goat_plugins.allora import allora, AlloraPluginOptions

# Initialize the plugin
options = AlloraPluginOptions(
    api_key="${OPENAI_API_KEY}",  # Your Allora API key
    model="allora-v1"  # Optional: Specify model version
)
plugin = allora(options)

# Get price prediction
prediction = await plugin.predict_price(
    token_address="0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
    chain_id=1,  # Ethereum
    timeframe="1d"  # Prediction timeframe
)

# Analyze token sentiment
sentiment = await plugin.analyze_sentiment(
    token_address="0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
    chain_id=1,
    data_sources=["social", "on-chain"]
)

# Get market insights
insights = await plugin.get_market_insights(
    chain_id=1,
    category="defi",
    timeframe="7d"
)
```

## Features

- AI-Powered Analytics:
  - Price predictions
  - Market sentiment analysis
  - Pattern recognition
  - Anomaly detection
  
- Data Integration:
  - On-chain data analysis
  - Social sentiment analysis
  - Technical indicators
  - Volume profiling
  
- Market Intelligence:
  - Trend identification
  - Risk assessment
  - Market correlation
  - Volatility analysis
  
- Supported Networks:
  - Ethereum
  - Polygon
  - BSC
  - Arbitrum
  - Optimism
  - Avalanche
  - Solana
  - Base
  
- Advanced Features:
  - Custom model training
  - Real-time predictions
  - Backtesting capabilities
  - Multi-timeframe analysis

## License

This project is licensed under the terms of the MIT license.
textconverterimp 0.1.5
A library to convert text into different formats.
Requires Python: >=3.6

# Text Converter

A Python library to convert text into different formats.

## Installation

```bash
pip install textconverterimp

```

## Usage
```bash
import textconverterim
a = 'Who kNow THat'
print(textconverterimp.to_title_case(a)) 
#or
import textconverterim as tc

a = 'Who kNow THat'
print(tc.to_title_case(a))
```
goat-sdk-plugin-1inch 0.1.1
1inch plugin for GOAT SDK
Requires Python: <4.0,>=3.10
Keywords: goat, sdk, web3, agents, ai, 1inch

# 1inch Plugin for GOAT SDK

A plugin for the GOAT SDK that provides 1inch DEX aggregator functionality.

## Installation

```bash
# Install the plugin
poetry add goat-sdk-plugin-1inch

# Install required wallet dependency
poetry add goat-sdk-wallet-evm
```

## Usage

```python
from goat_plugins.inch1 import inch1, Inch1PluginOptions

# Initialize the plugin
options = Inch1PluginOptions(
    api_key="${INCH1_API_KEY}"  # Optional: API key for higher rate limits
)
plugin = inch1(options)

# Get swap quote
quote = await plugin.get_swap_quote(
    chain_id=1,  # Ethereum mainnet
    from_token_address="0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",  # ETH
    to_token_address="0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
    amount="1000000000000000000"  # 1 ETH in wei
)
```

## Features

- DEX aggregation across multiple chains
- Swap quote functionality
- Token price discovery
- Supported chains:
  - Ethereum
  - Polygon
  - BSC
  - Arbitrum
  - Optimism
  - Avalanche
  - Gnosis Chain
  - Base

## License

This project is licensed under the terms of the MIT license.
key-rate-limiter 0.1.1
A rate limiter library for managing API key usage.
Requires Python: >=3.6

# Rate Limiter

Rate Limiter 是一个用于管理 API 密钥使用的限流库，支持滑动窗口速率限制。

## 特性

- 支持每个 API 密钥的自定义速率限制
- 使用 Redis 作为后端存储
- 提供简单的接口来获取可用的 API 密钥

## 安装

首先，确保你已经安装了 Python 和 Redis。然后，你可以通过以下命令安装依赖：

```bash
pip install -r requirements.txt
```

## 使用说明

以下是一个简单的使用示例：

```python
from rate_limiter import RateWindowLimiter

api_key_limits = {
    "api_key_1": {"max_rpm": 2, "max_tpm": 5000, "max_tpd": 100000},
    "api_key_2": {"max_rpm": 3, "max_tpm": 6000, "max_tpd": 120000},
    "api_key_3": {"max_rpm": 4, "max_tpm": 7000, "max_tpd": 140000},    
}

# 初始化Redis客户端
redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)

# 创建限流器
rate_limiter = RateWindowLimiter(api_key_limits=api_key_limits, redis_client=redis_client)

# 模拟请求
for _ in range(15):
    allowed, wait_time, api_key = rate_limiter.acquire()
    if allowed:
        print(f"请求成功，使用API密钥: {api_key}")
        # 执行API调用...
    else:
        print(f"需等待 {wait_time:.2f} 秒后重试，API密钥: {api_key}")
        time.sleep(wait_time)
```

## 贡献

欢迎贡献代码！请 fork 本仓库并提交 pull request。

## 许可证

本项目采用 MIT 许可证。详情请参阅 [LICENSE](LICENSE) 文件。