basileus 0.1.0__tar.gz

basileus-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: basileus
+Version: 0.1.0
+Summary: CLI for deploying Basileus autonomous prediction market agents
+Author: Basileus Team
+Requires-Python: >=3.11,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aleph-sdk-python (>=2.3.0,<3.0.0)
+Requires-Dist: eth-account (>=0.13.0,<0.14.0)
+Requires-Dist: paramiko (>=3.5.1,<4.0.0)
+Requires-Dist: pathspec (>=0.12.1,<0.13.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: typer[all] (>=0.15.0,<0.16.0)
+Requires-Dist: web3 (>=7.0.0,<8.0.0)
+Description-Content-Type: text/markdown
+
+# Basileus CLI
+
+CLI for deploying Basileus autonomous prediction market agents on Base.
+
+## Install
+
+```bash
+pip install basileus
+```
+
+## Usage
+
+```bash
+basileus deploy
+```
+

basileus-0.1.0/README.md

@@ -0,0 +1,15 @@
+# Basileus CLI
+
+CLI for deploying Basileus autonomous prediction market agents on Base.
+
+## Install
+
+```bash
+pip install basileus
+```
+
+## Usage
+
+```bash
+basileus deploy
+```

basileus-0.1.0/basileus/__main__.py

@@ -0,0 +1,3 @@
+from .main import app
+
+app(prog_name="basileus")

basileus-0.1.0/basileus/async_typer.py

@@ -0,0 +1,22 @@
+import asyncio
+from functools import wraps
+from typing import Any
+
+import typer
+
+
+class AsyncTyper(typer.Typer):
+    """Typer subclass that supports async command functions."""
+
+    def command(self, *args: Any, **kwargs: Any) -> Any:
+        decorator = super().command(*args, **kwargs)
+
+        def wrapper(fn: Any) -> Any:
+            @wraps(fn)
+            def runner(*a: Any, **kw: Any) -> Any:
+                return asyncio.run(fn(*a, **kw))
+
+            decorator(runner)
+            return fn
+
+        return wrapper

basileus-0.1.0/basileus/chain/balance.py

@@ -0,0 +1,34 @@
+import time
+
+from rich.console import Console
+from rich.live import Live
+from rich.spinner import Spinner
+from web3 import Web3
+
+from basileus.chain.constants import BASE_RPC_URL, MIN_ETH_FUNDING
+
+console = Console()
+
+
+def get_eth_balance(w3: Web3, address: str) -> float:
+    """Get native ETH balance for address. Returns human-readable float."""
+    raw = w3.eth.get_balance(Web3.to_checksum_address(address))
+    return raw / (10**18)
+
+
+def wait_for_eth_funding(
+    address: str, min_amount: float = MIN_ETH_FUNDING, poll_interval: int = 5
+) -> float:
+    """Poll RPC until ETH balance >= min_amount. Returns final balance."""
+    w3 = Web3(Web3.HTTPProvider(BASE_RPC_URL))
+
+    with Live(
+        Spinner("dots", text=f"Waiting for ETH deposit to {address}..."),
+        console=console,
+        transient=True,
+    ):
+        while True:
+            balance = get_eth_balance(w3, address)
+            if balance >= min_amount:
+                return balance
+            time.sleep(poll_interval)

basileus-0.1.0/basileus/chain/builder_code.py

@@ -0,0 +1,7 @@
+_ERC_SUFFIX = bytes.fromhex("80218021802180218021802180218021")
+
+
+def builder_code_suffix(code: str) -> bytes:
+    """ERC-8021 Schema 0: codes_ascii ∥ codesLength (1 byte) ∥ 0x00 ∥ ercSuffix (16 bytes)"""
+    codes_bytes = code.encode("ascii")
+    return codes_bytes + len(codes_bytes).to_bytes(1, "big") + b"\x00" + _ERC_SUFFIX

basileus-0.1.0/basileus/chain/constants.py

@@ -0,0 +1,202 @@
+# ERC-8021 builder code (Base)
+BUILDER_CODE = "bc_kj26kx76"
+
+# Base mainnet
+BASE_RPC_URL = "https://mainnet.base.org"
+BASE_CHAIN_ID = 8453
+
+# USDC on Base
+USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+USDC_DECIMALS = 6
+
+# WETH on Base
+WETH_ADDRESS = "0x4200000000000000000000000000000000000006"
+
+# ALEPH on Base
+ALEPH_ADDRESS = "0xc0Fbc4967259786C743361a5885ef49380473dCF"
+ALEPH_DECIMALS = 18
+
+# Uniswap V3 SwapRouter on Base
+UNISWAP_ROUTER = "0x2626664c2603336E57B271c5C0b26F421741e481"
+
+# Uniswap V3 ALEPH/WETH pool on Base
+UNISWAP_ALEPH_POOL = "0xe11C66b25F0e9a9eBEf1616B43424CC6E2168FC8"
+
+# Fee tiers
+UNISWAP_FEE_ALEPH = 10000  # 1% for WETH/ALEPH
+UNISWAP_FEE_USDC = 500  # 0.05% for WETH/USDC
+
+# Funding flow
+MIN_ETH_FUNDING = 0.01
+MIN_ETH_RESERVE = 0.001
+TARGET_ALEPH_TOKENS = 10
+
+# Minimal ERC20 ABI for balanceOf
+ERC20_BALANCE_ABI = [
+    {
+        "inputs": [{"name": "account", "type": "address"}],
+        "name": "balanceOf",
+        "outputs": [{"name": "", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    }
+]
+
+# L2Registrar on Base (ENS subnames for basileus-agent.eth)
+L2_REGISTRAR_ADDRESS = "0xBb3699a3018A8a82A94be194eCfe65512AD8E995"
+
+L2_REGISTRAR_ABI = [
+    {
+        "inputs": [{"name": "owner", "type": "address"}],
+        "name": "reverseNames",
+        "outputs": [{"name": "", "type": "string"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [{"name": "label", "type": "string"}],
+        "name": "available",
+        "outputs": [{"name": "", "type": "bool"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [
+            {"name": "label", "type": "string"},
+            {"name": "owner", "type": "address"},
+        ],
+        "name": "register",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+    },
+]
+
+# IPFS content hash (EIP-1577 encoded) — output of `npm run deploy:ipfs` in frontend/
+FRONTEND_CONTENT_HASH = (
+    "0xe30101701220166670f07c9a6e42f990a9326a8ee4224ef863b89fd17ff21f82a5cd43470125"
+)
+
+# L2Registry on Base (ENS resolver for subnames)
+L2_REGISTRY_ADDRESS = "0x2e84f843299a132103e110c948c5e4739682c961"
+
+L2_REGISTRY_ABI = [
+    {
+        "inputs": [],
+        "name": "baseNode",
+        "outputs": [{"name": "", "type": "bytes32"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [
+            {"name": "parentNode", "type": "bytes32"},
+            {"name": "label", "type": "string"},
+        ],
+        "name": "makeNode",
+        "outputs": [{"name": "", "type": "bytes32"}],
+        "stateMutability": "pure",
+        "type": "function",
+    },
+    {
+        "inputs": [
+            {"name": "node", "type": "bytes32"},
+            {"name": "hash", "type": "bytes"},
+        ],
+        "name": "setContenthash",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+    },
+    {
+        "inputs": [{"name": "node", "type": "bytes32"}],
+        "name": "contenthash",
+        "outputs": [{"name": "", "type": "bytes"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+]
+
+# ERC-8004 IdentityRegistry on Base
+ERC8004_IDENTITY_REGISTRY = "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432"
+
+ERC8004_IDENTITY_REGISTRY_ABI = [
+    {
+        "inputs": [
+            {"name": "agentURI", "type": "string"},
+            {
+                "name": "metadata",
+                "type": "tuple[]",
+                "components": [
+                    {"name": "key", "type": "string"},
+                    {"name": "value", "type": "bytes"},
+                ],
+            },
+        ],
+        "name": "register",
+        "outputs": [{"name": "agentId", "type": "uint256"}],
+        "stateMutability": "nonpayable",
+        "type": "function",
+    },
+    {
+        "inputs": [{"name": "owner", "type": "address"}],
+        "name": "balanceOf",
+        "outputs": [{"name": "", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "anonymous": False,
+        "inputs": [
+            {"indexed": True, "name": "agentId", "type": "uint256"},
+            {"indexed": False, "name": "agentURI", "type": "string"},
+            {"indexed": True, "name": "owner", "type": "address"},
+        ],
+        "name": "Registered",
+        "type": "event",
+    },
+]
+
+# Uniswap V3 pool ABI (slot0 for price reading)
+UNISWAP_POOL_ABI = [
+    {
+        "inputs": [],
+        "name": "slot0",
+        "outputs": [
+            {"name": "sqrtPriceX96", "type": "uint160"},
+            {"name": "tick", "type": "int24"},
+            {"name": "observationIndex", "type": "uint16"},
+            {"name": "observationCardinality", "type": "uint16"},
+            {"name": "observationCardinalityNext", "type": "uint16"},
+            {"name": "feeProtocol", "type": "uint8"},
+            {"name": "unlocked", "type": "bool"},
+        ],
+        "stateMutability": "view",
+        "type": "function",
+    }
+]
+
+# Uniswap V3 SwapRouter ABI (exactInputSingle)
+UNISWAP_ROUTER_ABI = [
+    {
+        "inputs": [
+            {
+                "components": [
+                    {"name": "tokenIn", "type": "address"},
+                    {"name": "tokenOut", "type": "address"},
+                    {"name": "fee", "type": "uint24"},
+                    {"name": "recipient", "type": "address"},
+                    {"name": "amountIn", "type": "uint256"},
+                    {"name": "amountOutMinimum", "type": "uint256"},
+                    {"name": "sqrtPriceLimitX96", "type": "uint160"},
+                ],
+                "name": "params",
+                "type": "tuple",
+            }
+        ],
+        "name": "exactInputSingle",
+        "outputs": [{"name": "amountOut", "type": "uint256"}],
+        "stateMutability": "payable",
+        "type": "function",
+    }
+]

basileus-0.1.0/basileus/chain/ens.py

@@ -0,0 +1,125 @@
+from web3 import Web3
+from eth_account import Account
+
+from basileus.chain.constants import (
+    BUILDER_CODE,
+    L2_REGISTRAR_ADDRESS,
+    L2_REGISTRAR_ABI,
+    L2_REGISTRY_ADDRESS,
+    L2_REGISTRY_ABI,
+)
+from basileus.chain.builder_code import builder_code_suffix
+
+
+def _get_registrar(w3: Web3):
+    return w3.eth.contract(
+        address=Web3.to_checksum_address(L2_REGISTRAR_ADDRESS),
+        abi=L2_REGISTRAR_ABI,
+    )
+
+
+def check_existing_subname(w3: Web3, address: str) -> str | None:
+    """Call reverseNames(address). Returns label or None if no subname."""
+    try:
+        contract = _get_registrar(w3)
+        label = contract.functions.reverseNames(
+            Web3.to_checksum_address(address)
+        ).call()
+        return label if label else None
+    except Exception:
+        return None
+
+
+def check_label_available(w3: Web3, label: str) -> bool:
+    """Call available(label). Returns True if label can be registered."""
+    contract = _get_registrar(w3)
+    return contract.functions.available(label).call()
+
+
+def register_subname(w3: Web3, private_key: str, label: str, owner: str) -> str:
+    """Call register(label, owner). Signs and sends tx. Returns tx hash hex.
+    Raises on failure."""
+    contract = _get_registrar(w3)
+    account = Account.from_key(private_key)
+    owner_checksummed = Web3.to_checksum_address(owner)
+
+    call = contract.functions.register(label, owner_checksummed)
+    tx = call.build_transaction(
+        {
+            "from": account.address,
+            "nonce": w3.eth.get_transaction_count(account.address, "pending"),
+            "gas": call.estimate_gas({"from": account.address}),
+        }
+    )
+
+    if BUILDER_CODE:
+        suffix = builder_code_suffix(BUILDER_CODE)
+        tx["data"] += suffix.hex()
+        tx["gas"] += len(suffix) * 16
+
+    signed = account.sign_transaction(tx)
+    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
+    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
+
+    if receipt["status"] != 1:
+        raise RuntimeError(f"Transaction reverted: 0x{tx_hash.hex()}")
+
+    return f"0x{tx_hash.hex()}"
+
+
+def _get_registry(w3: Web3):
+    return w3.eth.contract(
+        address=Web3.to_checksum_address(L2_REGISTRY_ADDRESS),
+        abi=L2_REGISTRY_ABI,
+    )
+
+
+def get_content_hash(w3: Web3, label: str) -> str | None:
+    """Read current contentHash from L2Registry for a subname. Returns hex string or None."""
+    registry = _get_registry(w3)
+    base_node = registry.functions.baseNode().call()
+    node = registry.functions.makeNode(base_node, label).call()
+    raw = registry.functions.contenthash(node).call()
+    if not raw:
+        return None
+    return f"0x{raw.hex()}"
+
+
+def set_content_hash(
+    w3: Web3, private_key: str, label: str, content_hash_hex: str
+) -> str:
+    """Set contentHash on L2Registry for a subname.
+
+    content_hash_hex: EIP-1577 encoded hex from the frontend deploy script (0x...).
+    Returns tx hash hex.
+    """
+    registry = _get_registry(w3)
+    account = Account.from_key(private_key)
+
+    base_node = registry.functions.baseNode().call()
+    node = registry.functions.makeNode(base_node, label).call()
+
+    content_hash = bytes.fromhex(content_hash_hex.removeprefix("0x"))
+
+    call = registry.functions.setContenthash(node, content_hash)
+    tx = call.build_transaction(
+        {
+            "from": account.address,
+            "nonce": w3.eth.get_transaction_count(account.address, "pending"),
+            "gas": call.estimate_gas({"from": account.address}),
+        }
+    )
+
+    if BUILDER_CODE:
+        suffix = builder_code_suffix(BUILDER_CODE)
+        tx["data"] += suffix.hex()
+        tx["gas"] += len(suffix) * 16
+
+    signed = account.sign_transaction(tx)
+    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
+    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
+
+    if receipt["status"] != 1:
+        raise RuntimeError(f"Transaction reverted: 0x{tx_hash.hex()}")
+
+    return f"0x{tx_hash.hex()}"

basileus-0.1.0/basileus/chain/erc8004.py

@@ -0,0 +1,127 @@
+"""ERC-8004 IdentityRegistry interactions for registering Basileus agents on Base."""
+
+import json
+import warnings
+
+import eth_abi
+from aleph.sdk.chains.ethereum import ETHAccount
+from aleph.sdk.client.authenticated_http import AuthenticatedAlephHttpClient
+from aleph.sdk.types import StorageEnum
+from eth_account import Account
+from web3 import Web3
+
+from basileus.chain.builder_code import builder_code_suffix
+from basileus.chain.constants import (
+    BUILDER_CODE,
+    ERC8004_IDENTITY_REGISTRY,
+    ERC8004_IDENTITY_REGISTRY_ABI,
+)
+from basileus.infra.aleph import ALEPH_API_URL, ALEPH_CHANNEL
+
+
+def _get_registry(w3: Web3):
+    return w3.eth.contract(
+        address=Web3.to_checksum_address(ERC8004_IDENTITY_REGISTRY),
+        abi=ERC8004_IDENTITY_REGISTRY_ABI,
+    )
+
+
+def build_agent_metadata(label: str) -> dict:
+    """Build ERC-8004 registration JSON for a Basileus agent."""
+    return {
+        "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
+        "name": f"{label}.basileus-agent.eth",
+        "description": "Autonomous prediction market trading agent on Base",
+        "image": "",
+        "services": [],
+        "x402Support": True,
+        "active": True,
+        "registrations": [],
+        "supportedTrust": [],
+    }
+
+
+async def upload_metadata_to_ipfs(
+    aleph_account: ETHAccount, metadata: dict, max_retries: int = 3
+) -> str:
+    """Upload agent metadata JSON to IPFS via Aleph. Returns ipfs:// URI."""
+    import asyncio
+
+    content_bytes = json.dumps(metadata, indent=2).encode("utf-8")
+
+    for attempt in range(max_retries):
+        try:
+            async with AuthenticatedAlephHttpClient(
+                account=aleph_account, api_server=ALEPH_API_URL
+            ) as client:
+                result, _status = await asyncio.wait_for(
+                    client.create_store(
+                        file_content=content_bytes,
+                        storage_engine=StorageEnum.ipfs,
+                        channel=ALEPH_CHANNEL,
+                        guess_mime_type=True,
+                    ),
+                    timeout=120,
+                )
+            cid = result.content.item_hash
+            return f"ipfs://{cid}"
+        except Exception:
+            if attempt >= max_retries - 1:
+                raise
+            await asyncio.sleep(3)
+    raise RuntimeError("IPFS upload failed after retries")
+
+
+def check_existing_registration(w3: Web3, address: str) -> bool:
+    """Check if address already owns an ERC-8004 identity NFT."""
+    contract = _get_registry(w3)
+    checksummed = Web3.to_checksum_address(address)
+    balance = contract.functions.balanceOf(checksummed).call()
+    return balance > 0
+
+
+def register_agent(
+    w3: Web3, private_key: str, agent_uri: str, ens_name: str
+) -> tuple[int, str]:
+    """Register agent on-chain via ERC-8004 IdentityRegistry.
+
+    Returns (agentId, tx_hash).
+    """
+    contract = _get_registry(w3)
+    account = Account.from_key(private_key)
+
+    # Encode ENS name as metadata entry: (key, abi-encoded value)
+    ens_value = eth_abi.encode(["string"], [ens_name])
+    metadata_entries = [("ens", ens_value)]
+
+    call = contract.functions.register(agent_uri, metadata_entries)
+    tx = call.build_transaction(
+        {
+            "from": account.address,
+            "nonce": w3.eth.get_transaction_count(account.address, "pending"),
+            "gas": call.estimate_gas({"from": account.address}),
+        }
+    )
+
+    if BUILDER_CODE:
+        suffix = builder_code_suffix(BUILDER_CODE)
+        tx["data"] += suffix.hex()
+        tx["gas"] += len(suffix) * 16
+
+    signed = account.sign_transaction(tx)
+    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
+    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
+
+    if receipt["status"] != 1:
+        raise RuntimeError(f"Transaction reverted: 0x{tx_hash.hex()}")
+
+    # Extract agentId from Registered event (suppress MismatchedABI warnings
+    # from unrelated logs like ERC-721 Transfer/Approval)
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message=".*MismatchedABI.*")
+        registered_events = contract.events.Registered().process_receipt(receipt)
+    if not registered_events:
+        raise RuntimeError(f"No Registered event found in tx 0x{tx_hash.hex()}")
+    agent_id = registered_events[0]["args"]["agentId"]
+
+    return (agent_id, f"0x{tx_hash.hex()}")

basileus-0.1.0/basileus/chain/superfluid.py

@@ -0,0 +1,91 @@
+import asyncio
+from dataclasses import dataclass
+from decimal import Decimal
+
+from aleph.sdk.chains.ethereum import ETHAccount
+from aleph.sdk.client.authenticated_http import AuthenticatedAlephHttpClient
+from aleph.sdk.evm_utils import FlowUpdate
+from aleph_message.models import InstanceMessage
+
+from basileus.infra.aleph import ALEPH_API_URL, COMMUNITY_RECEIVER, CRNInfo
+
+COMMUNITY_FLOW_PERCENTAGE = Decimal("0.2")
+
+
+@dataclass
+class FlowRates:
+    """Computed flow rates for operator and community."""
+
+    operator: Decimal
+    community: Decimal
+
+
+async def compute_flow_rates(
+    account: ETHAccount,
+    instance_hash: str,
+) -> FlowRates:
+    """Compute required Superfluid flow rates from instance pricing."""
+    async with AuthenticatedAlephHttpClient(
+        account=account, api_server=ALEPH_API_URL
+    ) as client:
+        instance_msg = await client.get_message(instance_hash, with_status=False)
+        if not isinstance(instance_msg, InstanceMessage):
+            raise ValueError(f"{instance_hash} is not an instance")
+
+        estimated = await client.get_estimated_price(content=instance_msg.content)
+        total_flow = Decimal(estimated.required_tokens)
+        return FlowRates(
+            operator=total_flow * (1 - COMMUNITY_FLOW_PERCENTAGE),
+            community=total_flow * COMMUNITY_FLOW_PERCENTAGE,
+        )
+
+
+def _check_tx(account: ETHAccount, tx_hash: str | None, label: str) -> None:
+    """Check that a tx succeeded on-chain. Raises if reverted."""
+    if tx_hash is None:
+        raise ValueError(f"{label}: no tx hash returned")
+    from hexbytes import HexBytes
+
+    receipt = account._provider.eth.wait_for_transaction_receipt(  # type: ignore[union-attr]
+        HexBytes(tx_hash), timeout=60
+    )
+    if receipt["status"] != 1:
+        raise ValueError(f"{label}: tx {tx_hash} reverted on-chain")
+
+
+async def create_operator_flow(
+    account: ETHAccount,
+    crn: CRNInfo,
+    flow_rate: Decimal,
+) -> str | None:
+    """Create operator Superfluid flow. Checks tx receipt. Returns tx hash."""
+    existing = await account.get_flow(crn.receiver_address)
+    existing_rate = Decimal(existing["flowRate"] or 0)
+    if existing_rate < flow_rate:
+        tx_hash = await account.manage_flow(
+            receiver=crn.receiver_address,
+            flow=flow_rate - existing_rate,
+            update_type=FlowUpdate.INCREASE,
+        )
+        _check_tx(account, tx_hash, "Operator flow")
+        return tx_hash
+    return None
+
+
+async def create_community_flow(
+    account: ETHAccount,
+    flow_rate: Decimal,
+) -> str | None:
+    """Create community Superfluid flow. Checks tx receipt. Returns tx hash."""
+    await asyncio.sleep(5)
+    existing = await account.get_flow(COMMUNITY_RECEIVER)
+    existing_rate = Decimal(existing["flowRate"] or 0)
+    if existing_rate < flow_rate:
+        tx_hash = await account.manage_flow(
+            receiver=COMMUNITY_RECEIVER,
+            flow=flow_rate - existing_rate,
+            update_type=FlowUpdate.INCREASE,
+        )
+        _check_tx(account, tx_hash, "Community flow")
+        return tx_hash
+    return None