cryptoagent-ai 0.1.0__tar.gz

cryptoagent_ai-0.1.0/.claude/settings.local.json

@@ -0,0 +1,15 @@
+{
+  "permissions": {
+    "allow": [
+      "WebSearch",
+      "Bash(pip install:*)",
+      "Bash(python -c:*)",
+      "Bash(python -m cli.main:*)",
+      "Bash(python -m build:*)",
+      "Bash(twine check:*)",
+      "Bash(twine upload:*)",
+      "Bash(TWINE_USERNAME=__token__ TWINE_PASSWORD=pypi-AgEIcHlwaS5vcmcCJDk1YThkNjc3LWNjNTUtNGU1Mi05YTkzLTgwYWVkOGM2OGQzMgACKlszLCI3YjVlODQzZC01M2E3LTRkMTQtOGNjMS0wZDg5NDU3OWEzMzUiXQAABiDC0ffAMKgCvZqXdhEztxeHys83JcIz6R--q-mJPGzwCw twine upload:*)",
+      "Bash(pip index:*)"
+    ]
+  }
+}

cryptoagent_ai-0.1.0/.env.example

@@ -0,0 +1,25 @@
+# Claude API
+ANTHROPIC_API_KEY=sk-ant-...
+
+# RPC Endpoints (override defaults in chains.yaml)
+ETH_RPC_URL=https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY
+BASE_RPC_URL=https://base-mainnet.g.alchemy.com/v2/YOUR_KEY
+ARBITRUM_RPC_URL=https://arb-mainnet.g.alchemy.com/v2/YOUR_KEY
+POLYGON_RPC_URL=https://polygon-mainnet.g.alchemy.com/v2/YOUR_KEY
+
+# Wallet encryption password
+WALLET_PASSWORD=change-me-to-a-strong-password
+
+# Safety
+MAX_TX_VALUE_USD=100.0
+DAILY_SPENDING_LIMIT_USD=1000.0
+REQUIRE_HUMAN_APPROVAL_ABOVE_USD=50.0
+
+# Price API (optional, falls back to Chainlink on-chain)
+COINGECKO_API_KEY=
+
+# Database
+DATABASE_URL=sqlite+aiosqlite:///data/agent.db
+
+# Logging
+LOG_LEVEL=INFO

cryptoagent_ai-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 coins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cryptoagent_ai-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: cryptoagent-ai
+Version: 0.1.0
+Summary: Autonomous AI agents that own wallets and transact on EVM chains
+Project-URL: Homepage, https://github.com/coins/cryptoagent-ai
+Project-URL: Repository, https://github.com/coins/cryptoagent-ai
+Author-email: coins <gobeyondfj@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,ai,claude,crypto,defi,ethereum,web3
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Dist: anthropic>=0.40.0
+Requires-Dist: cryptography>=44.0.0
+Requires-Dist: eth-account>=0.13.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: mnemonic>=0.21
+Requires-Dist: pydantic-settings>=2.6.0
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich>=13.9.0
+Requires-Dist: sqlmodel>=0.0.22
+Requires-Dist: structlog>=24.4.0
+Requires-Dist: tenacity>=9.0.0
+Requires-Dist: typer[all]>=0.12.0
+Requires-Dist: web3>=7.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# CryptoAgent AI
+
+Autonomous AI agents that own wallets and independently transact on EVM chains (Ethereum, Base, Arbitrum, Polygon), powered by Claude API.
+
+## Features
+
+- **HD Wallets** — BIP-44 derivation with Fernet+PBKDF2 encrypted key storage
+- **Multi-chain** — Ethereum, Base, Arbitrum, Polygon with failover RPC
+- **DeFi Protocols** — Uniswap V3 swaps, Aave V3 lending
+- **Safety First** — Spending limits, slippage guards, human approval, audit log
+- **AI Agent Loop** — Perceive → Reason (Claude) → Act → Reflect
+- **16 Tools** — Balances, swaps, lending, portfolio, memory — all exposed to Claude
+
+## Install
+
+```bash
+pip install cryptoagent-ai
+```
+
+## Quick Start
+
+```bash
+# Show config
+cryptoagent info
+
+# Create a wallet
+cryptoagent wallet create my-wallet -p "strong-password"
+
+# Start an agent
+export ANTHROPIC_API_KEY=sk-ant-...
+cryptoagent agent start --wallet my-wallet -p "strong-password"
+```
+
+## Architecture
+
+```
+EventMonitor → PERCEIVE (balances, events, portfolio)
+                  ↓
+              REASON (Claude + tool-use)
+                  ↓
+              ACT (Guardian safety checks → execute → audit)
+                  ↓
+              REFLECT (update portfolio, log metrics)
+                  ↓
+              sleep → loop
+```
+
+## Security
+
+- Keys encrypted at rest (Fernet + PBKDF2, 600k iterations)
+- Per-transaction, hourly, and daily USD spending caps
+- Human-in-the-loop approval for high-value transactions
+- Slippage protection on all swaps
+- Append-only audit log
+
+## License
+
+MIT

cryptoagent_ai-0.1.0/README.md

@@ -0,0 +1,58 @@
+# CryptoAgent AI
+
+Autonomous AI agents that own wallets and independently transact on EVM chains (Ethereum, Base, Arbitrum, Polygon), powered by Claude API.
+
+## Features
+
+- **HD Wallets** — BIP-44 derivation with Fernet+PBKDF2 encrypted key storage
+- **Multi-chain** — Ethereum, Base, Arbitrum, Polygon with failover RPC
+- **DeFi Protocols** — Uniswap V3 swaps, Aave V3 lending
+- **Safety First** — Spending limits, slippage guards, human approval, audit log
+- **AI Agent Loop** — Perceive → Reason (Claude) → Act → Reflect
+- **16 Tools** — Balances, swaps, lending, portfolio, memory — all exposed to Claude
+
+## Install
+
+```bash
+pip install cryptoagent-ai
+```
+
+## Quick Start
+
+```bash
+# Show config
+cryptoagent info
+
+# Create a wallet
+cryptoagent wallet create my-wallet -p "strong-password"
+
+# Start an agent
+export ANTHROPIC_API_KEY=sk-ant-...
+cryptoagent agent start --wallet my-wallet -p "strong-password"
+```
+
+## Architecture
+
+```
+EventMonitor → PERCEIVE (balances, events, portfolio)
+                  ↓
+              REASON (Claude + tool-use)
+                  ↓
+              ACT (Guardian safety checks → execute → audit)
+                  ↓
+              REFLECT (update portfolio, log metrics)
+                  ↓
+              sleep → loop
+```
+
+## Security
+
+- Keys encrypted at rest (Fernet + PBKDF2, 600k iterations)
+- Per-transaction, hourly, and daily USD spending caps
+- Human-in-the-loop approval for high-value transactions
+- Slippage protection on all swaps
+- Append-only audit log
+
+## License
+
+MIT

cryptoagent_ai-0.1.0/chain/abi_registry.py

@@ -0,0 +1,57 @@
+"""ABI loading and caching registry."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from chain.constants import ERC20_ABI
+
+# Built-in ABIs
+_BUILTIN_ABIS: dict[str, list[dict[str, Any]]] = {
+    "erc20": ERC20_ABI,
+}
+
+# File-based ABI cache
+_ABI_DIR = Path("config/abis")
+_cache: dict[str, list[dict[str, Any]]] = {}
+
+
+def get_abi(name: str) -> list[dict[str, Any]]:
+    """Get an ABI by name.
+
+    Checks built-in ABIs first, then file cache, then config/abis/ directory.
+    """
+    # Built-in
+    if name in _BUILTIN_ABIS:
+        return _BUILTIN_ABIS[name]
+
+    # Memory cache
+    if name in _cache:
+        return _cache[name]
+
+    # Load from file
+    path = _ABI_DIR / f"{name}.json"
+    if path.exists():
+        with open(path) as f:
+            abi = json.load(f)
+        _cache[name] = abi
+        return abi
+
+    raise ValueError(f"ABI not found: {name}")
+
+
+def register_abi(name: str, abi: list[dict[str, Any]]) -> None:
+    """Register an ABI in the runtime cache."""
+    _cache[name] = abi
+
+
+def save_abi(name: str, abi: list[dict[str, Any]]) -> Path:
+    """Save an ABI to the config/abis directory."""
+    _ABI_DIR.mkdir(parents=True, exist_ok=True)
+    path = _ABI_DIR / f"{name}.json"
+    with open(path, "w") as f:
+        json.dump(abi, f, indent=2)
+    _cache[name] = abi
+    return path

cryptoagent_ai-0.1.0/chain/client.py

@@ -0,0 +1,207 @@
+"""High-level blockchain client for read/write operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import structlog
+from web3 import AsyncWeb3
+
+from chain.constants import ERC20_ABI, NATIVE_TOKEN
+from chain.provider import ChainProvider, MultiChainProvider
+from chain.transaction import NonceManager, TransactionBuilder
+from core.exceptions import (
+    ChainError,
+    InsufficientFundsError,
+    TransactionError,
+    TransactionRevertedError,
+)
+from core.types import TokenInfo, TransactionReceipt, TransactionRequest
+from wallet.signer import TransactionSigner
+
+logger = structlog.get_logger(__name__)
+
+
+class ChainClient:
+    """High-level async client for reading and writing to EVM chains."""
+
+    def __init__(
+        self,
+        providers: MultiChainProvider,
+        signer: TransactionSigner,
+        nonce_manager: NonceManager | None = None,
+    ) -> None:
+        self._providers = providers
+        self._signer = signer
+        self._nonce_manager = nonce_manager or NonceManager()
+
+    def _get_provider(self, chain_id: int) -> ChainProvider:
+        return self._providers.get(chain_id)
+
+    # ── Read Operations ────────────────────────────────────────────────
+
+    async def get_eth_balance(self, chain_id: int, address: str | None = None) -> int:
+        """Get native token balance in wei."""
+        address = address or self._signer.address
+        provider = self._get_provider(chain_id)
+        return await provider.get_balance(address)
+
+    async def get_token_balance(
+        self, chain_id: int, token_address: str, address: str | None = None
+    ) -> int:
+        """Get ERC-20 token balance (raw units)."""
+        address = address or self._signer.address
+        provider = self._get_provider(chain_id)
+        contract = provider.w3.eth.contract(
+            address=AsyncWeb3.to_checksum_address(token_address),
+            abi=ERC20_ABI,
+        )
+        return await contract.functions.balanceOf(
+            AsyncWeb3.to_checksum_address(address)
+        ).call()
+
+    async def get_token_info(self, chain_id: int, token_address: str) -> TokenInfo:
+        """Get token metadata (symbol, decimals, name)."""
+        provider = self._get_provider(chain_id)
+        contract = provider.w3.eth.contract(
+            address=AsyncWeb3.to_checksum_address(token_address),
+            abi=ERC20_ABI,
+        )
+        symbol, decimals, name = await asyncio.gather(
+            contract.functions.symbol().call(),
+            contract.functions.decimals().call(),
+            contract.functions.name().call(),
+        )
+        return TokenInfo(
+            address=token_address,
+            symbol=symbol,
+            decimals=decimals,
+            chain_id=chain_id,
+            name=name,
+        )
+
+    async def get_allowance(
+        self,
+        chain_id: int,
+        token_address: str,
+        spender: str,
+        owner: str | None = None,
+    ) -> int:
+        """Get ERC-20 allowance."""
+        owner = owner or self._signer.address
+        provider = self._get_provider(chain_id)
+        contract = provider.w3.eth.contract(
+            address=AsyncWeb3.to_checksum_address(token_address),
+            abi=ERC20_ABI,
+        )
+        return await contract.functions.allowance(
+            AsyncWeb3.to_checksum_address(owner),
+            AsyncWeb3.to_checksum_address(spender),
+        ).call()
+
+    async def get_gas_price(self, chain_id: int) -> int:
+        """Get current gas price in wei."""
+        provider = self._get_provider(chain_id)
+        return await provider.get_gas_price()
+
+    async def get_block_number(self, chain_id: int) -> int:
+        provider = self._get_provider(chain_id)
+        return await provider.get_block_number()
+
+    # ── Write Operations ───────────────────────────────────────────────
+
+    async def send_transaction(self, request: TransactionRequest) -> TransactionReceipt:
+        """Build, sign, send, and wait for a transaction."""
+        provider = self._get_provider(request.chain_id)
+        builder = TransactionBuilder(provider, self._nonce_manager)
+
+        # Build tx dict
+        tx_dict = await builder.build(request, self._signer.address)
+
+        # Check balance
+        balance = await provider.get_balance(self._signer.address)
+        total_cost = request.value + (tx_dict["gas"] * tx_dict["maxFeePerGas"])
+        if balance < total_cost:
+            raise InsufficientFundsError(
+                f"Balance {balance} wei < required {total_cost} wei"
+            )
+
+        # Sign
+        raw_tx = self._signer.sign_transaction(tx_dict)
+
+        # Send
+        try:
+            tx_hash = await provider.call("eth.send_raw_transaction", raw_tx)
+            self._nonce_manager.confirm_nonce(
+                request.chain_id, self._signer.address, tx_dict["nonce"]
+            )
+        except Exception as e:
+            self._nonce_manager.reset(request.chain_id, self._signer.address)
+            raise TransactionError(f"Failed to send transaction: {e}") from e
+
+        # Wait for receipt
+        logger.info("transaction_sent", tx_hash=tx_hash.hex(), chain_id=request.chain_id)
+        receipt = await provider.call("eth.wait_for_transaction_receipt", tx_hash, timeout=120)
+
+        result = TransactionReceipt(
+            tx_hash=receipt["transactionHash"].hex(),
+            chain_id=request.chain_id,
+            block_number=receipt["blockNumber"],
+            gas_used=receipt["gasUsed"],
+            status=receipt["status"],
+            logs=[dict(log) for log in receipt.get("logs", [])],
+        )
+
+        if not result.success:
+            raise TransactionRevertedError(result.tx_hash, "Transaction reverted")
+
+        logger.info(
+            "transaction_confirmed",
+            tx_hash=result.tx_hash,
+            block=result.block_number,
+            gas_used=result.gas_used,
+        )
+        return result
+
+    async def send_eth(
+        self, chain_id: int, to: str, value_wei: int, description: str = ""
+    ) -> TransactionReceipt:
+        """Send native ETH/MATIC."""
+        request = TransactionRequest(
+            chain_id=chain_id,
+            to=to,
+            value=value_wei,
+            description=description or f"Send {value_wei} wei to {to}",
+        )
+        return await self.send_transaction(request)
+
+    async def approve_token(
+        self,
+        chain_id: int,
+        token_address: str,
+        spender: str,
+        amount: int | None = None,
+    ) -> TransactionReceipt:
+        """Approve an ERC-20 token for spending."""
+        max_uint256 = 2**256 - 1
+        amount = amount if amount is not None else max_uint256
+        provider = self._get_provider(chain_id)
+        contract = provider.w3.eth.contract(
+            address=AsyncWeb3.to_checksum_address(token_address),
+            abi=ERC20_ABI,
+        )
+        data = contract.functions.approve(
+            AsyncWeb3.to_checksum_address(spender), amount
+        )._encode_transaction_data()
+
+        request = TransactionRequest(
+            chain_id=chain_id,
+            to=token_address,
+            data=bytes.fromhex(data[2:]) if isinstance(data, str) else data,
+            description=f"Approve {spender} to spend token {token_address}",
+        )
+        return await self.send_transaction(request)
+
+
+# Missing import
+import asyncio

cryptoagent_ai-0.1.0/chain/constants.py

@@ -0,0 +1,122 @@
+"""Well-known contract addresses per chain."""
+
+from __future__ import annotations
+
+from core.types import ChainId
+
+# Native ETH sentinel address (used by protocols to represent native gas token)
+NATIVE_TOKEN = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
+
+# WETH addresses per chain
+WETH: dict[int, str] = {
+    ChainId.ETHEREUM: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    ChainId.BASE: "0x4200000000000000000000000000000000000006",
+    ChainId.ARBITRUM: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    ChainId.POLYGON: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",  # WMATIC
+}
+
+# USDC addresses per chain
+USDC: dict[int, str] = {
+    ChainId.ETHEREUM: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    ChainId.BASE: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    ChainId.ARBITRUM: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    ChainId.POLYGON: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+}
+
+# USDT addresses per chain
+USDT: dict[int, str] = {
+    ChainId.ETHEREUM: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    ChainId.ARBITRUM: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+    ChainId.POLYGON: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+}
+
+# DAI addresses per chain
+DAI: dict[int, str] = {
+    ChainId.ETHEREUM: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+    ChainId.BASE: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+    ChainId.ARBITRUM: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+    ChainId.POLYGON: "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
+}
+
+# Multicall3 — same address on all supported chains
+MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11"
+
+# ERC-20 minimal ABI for balance/approve/transfer
+ERC20_ABI = [
+    {
+        "constant": True,
+        "inputs": [{"name": "account", "type": "address"}],
+        "name": "balanceOf",
+        "outputs": [{"name": "", "type": "uint256"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [{"name": "", "type": "uint8"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [{"name": "", "type": "string"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "name",
+        "outputs": [{"name": "", "type": "string"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [
+            {"name": "owner", "type": "address"},
+            {"name": "spender", "type": "address"},
+        ],
+        "name": "allowance",
+        "outputs": [{"name": "", "type": "uint256"}],
+        "type": "function",
+    },
+    {
+        "constant": False,
+        "inputs": [
+            {"name": "spender", "type": "address"},
+            {"name": "amount", "type": "uint256"},
+        ],
+        "name": "approve",
+        "outputs": [{"name": "", "type": "bool"}],
+        "type": "function",
+    },
+    {
+        "constant": False,
+        "inputs": [
+            {"name": "to", "type": "address"},
+            {"name": "amount", "type": "uint256"},
+        ],
+        "name": "transfer",
+        "outputs": [{"name": "", "type": "bool"}],
+        "type": "function",
+    },
+    {
+        "constant": False,
+        "inputs": [
+            {"name": "from", "type": "address"},
+            {"name": "to", "type": "address"},
+            {"name": "amount", "type": "uint256"},
+        ],
+        "name": "transferFrom",
+        "outputs": [{"name": "", "type": "bool"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [{"name": "", "type": "uint256"}],
+        "type": "function",
+    },
+]