iwa 0.0.0__py3-none-any.whl → 0.0.1a2__py3-none-any.whl

iwa/web/models.py

@@ -0,0 +1,76 @@
+"""Shared request models for Web API."""
+
+from typing import List
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class AccountCreateRequest(BaseModel):
+    """Request model for creating an EOA."""
+
+    tag: str = Field(description="Human-readable tag for the new account")
+
+    @field_validator("tag")
+    @classmethod
+    def validate_tag(cls, v: str) -> str:
+        """Validate tag is not empty and alphanumeric."""
+        if not v or not v.strip():
+            raise ValueError("Tag cannot be empty")
+        if not v.replace("_", "").replace("-", "").isalnum():
+            raise ValueError("Tag contains invalid characters")
+        return v
+
+
+class SafeCreateRequest(BaseModel):
+    """Request model for creating a Safe."""
+
+    tag: str = Field(description="Human-readable tag for the Safe")
+    owners: List[str] = Field(description="List of owner addresses (checksummed or lowercase)")
+    threshold: int = Field(description="Required signatures threshold")
+    chains: List[str] = Field(default=["gnosis"], description="List of chains to deploy on")
+
+    @field_validator("owners")
+    @classmethod
+    def validate_owners(cls, v: List[str]) -> List[str]:
+        """Validate owners list is not empty and contains valid addresses or tags."""
+        if not v:
+            raise ValueError("Owners list cannot be empty")
+        for owner in v:
+            # Accept both addresses (0x...) and tags (alphanumeric with _ and -)
+            if owner.startswith("0x"):
+                if len(owner) != 42:
+                    raise ValueError(f"Invalid owner address: {owner}")
+            else:
+                # Tag format validation
+                if not owner.replace("_", "").replace("-", "").replace(" ", "").isalnum():
+                    raise ValueError(f"Invalid owner tag: {owner}")
+        # Check for duplicates
+        if len(v) != len(set(v)):
+            raise ValueError("Duplicate owners not allowed")
+        return v
+
+    @field_validator("threshold")
+    @classmethod
+    def validate_threshold(cls, v: int, info) -> int:
+        """Validate threshold is valid."""
+        if v < 1:
+            raise ValueError("Threshold must be at least 1")
+        # Access owners if available to validate threshold <= len(owners)
+        # Note: Pydantic V2 uses ValidationInfo, V1 uses 'values' dict. Assuming V2 based on usage.
+        # If 'owners' failed validation, it might not be in info.data
+        if info.data and "owners" in info.data:
+            owners = info.data["owners"]
+            if v > len(owners):
+                raise ValueError("Threshold cannot be greater than number of owners")
+        return v
+
+    @field_validator("chains")
+    @classmethod
+    def validate_chains(cls, v: List[str]) -> List[str]:
+        """Validate chains list."""
+        if not v:
+            raise ValueError("Must specify at least one chain")
+        for chain in v:
+            if not chain.replace("-", "").isalnum():
+                raise ValueError(f"Invalid chain name: {chain}")
+        return v

iwa/web/routers/accounts.py

@@ -0,0 +1,115 @@
+"""Accounts Router for Web API."""
+
+import logging
+import time
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+from iwa.web.dependencies import verify_auth, wallet
+from iwa.web.models import AccountCreateRequest, SafeCreateRequest
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/api/accounts", tags=["accounts"])
+
+# Rate limiter for this router
+limiter = Limiter(key_func=get_remote_address)
+
+
+@router.get(
+    "",
+    summary="Get accounts",
+    description="Retrieve all stored accounts and their balances for the specified chain.",
+)
+def get_accounts(
+    chain: str = "gnosis",
+    tokens: str = None,
+    auth: bool = Depends(verify_auth),
+):
+    """Get all accounts and their balances for a specific chain."""
+    if not chain.replace("-", "").isalnum():
+        raise HTTPException(status_code=400, detail="Invalid chain name")
+    try:
+        # Parse tokens from query parameter or use defaults
+        if tokens:
+            token_names = [t.strip() for t in tokens.split(",") if t.strip()]
+        else:
+            token_names = ["native", "OLAS", "WXDAI", "USDC"]
+
+        accounts_data, balances = wallet.get_accounts_balances(chain, token_names)
+
+        # Merge data
+        result = []
+        for addr, data in accounts_data.items():
+            account_balances = balances.get(addr, {})
+            # Determine account type: if it has 'signers' attribute, it's a Safe
+            account_type = "Safe" if hasattr(data, "signers") else "EOA"
+            result.append(
+                {
+                    "address": addr,
+                    "tag": data.tag,
+                    "type": account_type,
+                    "balances": account_balances,
+                }
+            )
+
+        return result
+    except Exception as e:
+        logger.error(f"Error fetching accounts: {e}")
+        raise HTTPException(status_code=500, detail=str(e)) from None
+
+
+@router.post(
+    "/eoa",
+    summary="Create EOA",
+    description="Create a new Externally Owned Account (EOA) with a unique tag.",
+)
+@limiter.limit("5/minute")
+def create_eoa(request: Request, req: AccountCreateRequest, auth: bool = Depends(verify_auth)):
+    """Create a new EOA account with the given tag."""
+    try:
+        wallet.key_storage.create_account(req.tag)
+        return {"status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e)) from None
+
+
+@router.post(
+    "/safe",
+    summary="Create Safe",
+    description="Deploy a new Gnosis Safe multisig wallet on selected chains.",
+)
+@limiter.limit("3/minute")
+def create_safe(request: Request, req: SafeCreateRequest, auth: bool = Depends(verify_auth)):
+    """Create a new Safe multisig account."""
+    try:
+        # We use a timestamp-based salt to avoid collisions
+        salt_nonce = int(time.time() * 1000)
+
+        # Resolve owner tags to addresses
+        resolved_owners = []
+        for owner in req.owners:
+            if owner.startswith("0x"):
+                resolved_owners.append(owner)
+            else:
+                # It's a tag, resolve to address
+                account = wallet.account_service.resolve_account(owner)
+                if not account:
+                    raise ValueError(f"Owner account not found: {owner}")
+                resolved_owners.append(account.address)
+
+        # Deploy on all requested chains
+        for chain_name in req.chains:
+            wallet.safe_service.create_safe(
+                "master",  # WebUI uses master as deployer by default
+                resolved_owners,
+                req.threshold,
+                chain_name,
+                req.tag,
+                salt_nonce,
+            )
+        return {"status": "success"}
+    except Exception as e:
+        logger.error(f"Error creating Safe: {e}")
+        raise HTTPException(status_code=400, detail=str(e)) from None

iwa/web/routers/olas/__init__.py

@@ -0,0 +1,24 @@
+"""Olas Router Package."""
+
+from fastapi import APIRouter
+
+from iwa.core.models import Config
+from iwa.plugins.olas.models import OlasConfig
+from iwa.web.routers.olas.admin import router as admin_router
+from iwa.web.routers.olas.funding import router as funding_router
+from iwa.web.routers.olas.general import router as general_router
+from iwa.web.routers.olas.services import router as services_router
+from iwa.web.routers.olas.staking import router as staking_router
+
+# Create main router
+router = APIRouter(prefix="/api/olas", tags=["olas"])
+
+# Include sub-routers directly without extra prefix/tags (already set in main or sub)
+# Note: Sub-routers define their own endpoints relative to the main router root
+router.include_router(general_router)
+router.include_router(services_router)
+router.include_router(staking_router)
+router.include_router(funding_router)
+router.include_router(admin_router)
+
+__all__ = ["router", "Config", "OlasConfig"]

iwa/web/routers/olas/admin.py

@@ -0,0 +1,169 @@
+"""Olas Admin Router."""
+
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+from iwa.core.models import Config
+from iwa.plugins.olas.models import OlasConfig
+from iwa.web.dependencies import verify_auth, wallet
+
+logger = logging.getLogger(__name__)
+router = APIRouter(tags=["olas"])
+limiter = Limiter(key_func=get_remote_address)
+
+
+@router.post(
+    "/activate/{service_key}",
+    summary="Activate Registration",
+    description="Activate registration for a service (step 1 after creation).",
+)
+def activate_registration(service_key: str, auth: bool = Depends(verify_auth)):
+    """Activate service registration."""
+    try:
+        from iwa.plugins.olas.service_manager import ServiceManager
+
+        config = Config()
+        olas_config = OlasConfig.model_validate(config.plugins["olas"])
+        service = olas_config.services.get(service_key)
+
+        if not service:
+            raise HTTPException(status_code=404, detail="Service not found")
+
+        manager = ServiceManager(wallet)
+        manager.service = service
+
+        success = manager.activate_registration()
+        if success:
+            return {"status": "success"}
+        else:
+            raise HTTPException(status_code=400, detail="Failed to activate registration")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error activating registration: {e}")
+        raise HTTPException(status_code=400, detail=str(e)) from None
+
+
+@router.post(
+    "/register/{service_key}",
+    summary="Register Agent",
+    description="Register an agent for the service (step 2 after activation).",
+)
+def register_agent(service_key: str, auth: bool = Depends(verify_auth)):
+    """Register agent for service."""
+    try:
+        from iwa.plugins.olas.service_manager import ServiceManager
+
+        config = Config()
+        olas_config = OlasConfig.model_validate(config.plugins["olas"])
+        service = olas_config.services.get(service_key)
+
+        if not service:
+            raise HTTPException(status_code=404, detail="Service not found")
+
+        manager = ServiceManager(wallet)
+        manager.service = service
+
+        success = manager.register_agent()
+        if success:
+            return {"status": "success"}
+        else:
+            raise HTTPException(status_code=400, detail="Failed to register agent")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error registering agent: {e}")
+        raise HTTPException(status_code=400, detail=str(e)) from None
+
+
+@router.post(
+    "/deploy-step/{service_key}",
+    summary="Deploy Service (Step 3)",
+    description="Deploy the service (step 3, creates multisig Safe).",
+)
+def deploy_service_step(service_key: str, auth: bool = Depends(verify_auth)):
+    """Deploy the service."""
+    try:
+        from iwa.plugins.olas.service_manager import ServiceManager
+
+        config = Config()
+        olas_config = OlasConfig.model_validate(config.plugins["olas"])
+        service = olas_config.services.get(service_key)
+
+        if not service:
+            raise HTTPException(status_code=404, detail="Service not found")
+
+        manager = ServiceManager(wallet)
+        manager.service = service
+
+        success = manager.deploy()
+        if success:
+            return {"status": "success"}
+        else:
+            raise HTTPException(status_code=400, detail="Failed to deploy service")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deploying service: {e}")
+        raise HTTPException(status_code=400, detail=str(e)) from None
+
+
+@router.post(
+    "/terminate/{service_key}",
+    summary="Terminate Service",
+    description="Wind down a service: unstake (if staked) → terminate → unbond.",
+)
+@limiter.limit("3/minute")
+def terminate_service(request: Request, service_key: str, auth: bool = Depends(verify_auth)):
+    """Terminate and unbond a service using wind_down."""
+    try:
+        from iwa.plugins.olas.contracts.staking import StakingContract
+        from iwa.plugins.olas.service_manager import ServiceManager
+
+        config = Config()
+        olas_config = OlasConfig.model_validate(config.plugins["olas"])
+        service = olas_config.services.get(service_key)
+
+        if not service:
+            raise HTTPException(status_code=404, detail="Service not found")
+
+        manager = ServiceManager(wallet)
+        manager.service = service
+
+        # Get current state for logging
+        current_state = manager.get_service_state()
+        logger.info(f"[WIND_DOWN] Service {service_key} state: {current_state}")
+
+        if current_state == "PRE_REGISTRATION":
+            return {"status": "success", "message": "Service already in PRE_REGISTRATION state"}
+
+        if current_state == "NON_EXISTENT":
+            raise HTTPException(status_code=400, detail="Service does not exist")
+
+        # Prepare staking contract if service is staked
+        staking_contract = None
+        if service.staking_contract_address:
+            staking_contract = StakingContract(service.staking_contract_address, service.chain_name)
+
+        # Use wind_down which handles unstake → terminate → unbond
+        success = manager.wind_down(staking_contract=staking_contract)
+
+        if success:
+            return {"status": "success", "message": "Service wound down to PRE_REGISTRATION"}
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail="Wind down failed. Check logs for details.",
+            )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error winding down service: {e}")
+        raise HTTPException(status_code=400, detail=str(e)) from None

iwa/web/routers/olas/funding.py

@@ -0,0 +1,135 @@
+"""Olas Funding Router."""
+
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel, Field
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+from iwa.core.models import Config
+from iwa.plugins.olas.models import OlasConfig
+from iwa.web.dependencies import verify_auth, wallet
+
+logger = logging.getLogger(__name__)
+router = APIRouter(tags=["olas"])
+limiter = Limiter(key_func=get_remote_address)
+
+
+class FundRequest(BaseModel):
+    """Request model for funding a service."""
+
+    agent_amount_eth: float = Field(default=0, description="Amount to fund agent in ETH")
+    safe_amount_eth: float = Field(default=0, description="Amount to fund safe in ETH")
+
+
+@router.post(
+    "/fund/{service_key}",
+    summary="Fund Service",
+    description="Fund a service's agent and safe accounts with native currency.",
+)
+def fund_service(service_key: str, req: FundRequest, auth: bool = Depends(verify_auth)):
+    """Fund a service's agent and safe accounts."""
+    try:
+        from web3 import Web3
+
+        config = Config()
+        olas_config = OlasConfig.model_validate(config.plugins["olas"])
+        service = olas_config.services.get(service_key)
+
+        if not service:
+            raise HTTPException(status_code=404, detail="Service not found")
+
+        funded = {}
+
+        # Fund agent if amount provided and agent exists
+        if req.agent_amount_eth > 0 and service.agent_address:
+            amount_wei = Web3.to_wei(req.agent_amount_eth, "ether")
+            tx_hash = wallet.send(
+                from_address_or_tag="master",
+                to_address_or_tag=service.agent_address,
+                amount_wei=amount_wei,
+                token_address_or_name="native",
+                chain_name=service.chain_name,
+            )
+            funded["agent"] = {"amount": req.agent_amount_eth, "tx_hash": tx_hash}
+
+        # Fund safe if amount provided and safe exists
+        if req.safe_amount_eth > 0 and service.multisig_address:
+            amount_wei = Web3.to_wei(req.safe_amount_eth, "ether")
+            tx_hash = wallet.send(
+                from_address_or_tag="master",
+                to_address_or_tag=str(service.multisig_address),
+                amount_wei=amount_wei,
+                token_address_or_name="native",
+                chain_name=service.chain_name,
+            )
+            funded["safe"] = {"amount": req.safe_amount_eth, "tx_hash": tx_hash}
+
+        if not funded:
+            raise HTTPException(
+                status_code=400, detail="No valid accounts to fund or amounts are zero"
+            )
+
+        return {"status": "success", "funded": funded}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error funding service: {e}")
+        raise HTTPException(status_code=400, detail=str(e)) from None
+
+
+@router.post(
+    "/drain/{service_key}",
+    summary="Drain Service",
+    description="Drain all funds from a service's accounts to the master account.",
+)
+@limiter.limit("3/minute")
+def drain_service(request: Request, service_key: str, auth: bool = Depends(verify_auth)):
+    """Drain all funds from a service's accounts."""
+    try:
+        from iwa.plugins.olas.service_manager import ServiceManager
+
+        config = Config()
+        olas_config = OlasConfig.model_validate(config.plugins["olas"])
+        service = olas_config.services.get(service_key)
+
+        if not service:
+            raise HTTPException(status_code=404, detail="Service not found")
+
+        manager = ServiceManager(wallet)
+        manager.service = service
+
+        logger.info(f"[DRAIN] Starting drain for service {service_key}")
+        logger.info(f"[DRAIN] Agent: {service.agent_address}")
+        logger.info(f"[DRAIN] Safe: {service.multisig_address}")
+        logger.info(f"[DRAIN] Owner: {service.service_owner_address}")
+
+        # Drain all accounts (Safe, Agent, Owner)
+        try:
+            drained = manager.drain_service()
+            logger.info(f"[DRAIN] drain_service returned: {drained}")
+        except Exception as drain_ex:
+            logger.error(f"[DRAIN] drain_service threw exception: {drain_ex}")
+            import traceback
+
+            logger.error(f"[DRAIN] Traceback: {traceback.format_exc()}")
+            raise HTTPException(status_code=400, detail=str(drain_ex)) from drain_ex
+
+        if not drained:
+            raise HTTPException(
+                status_code=400,
+                detail="Nothing drained. Accounts may have no balance or private keys may be missing.",
+            )
+
+        return {
+            "status": "success",
+            "drained": drained,
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error draining service: {e}")
+        raise HTTPException(status_code=400, detail=str(e)) from None

iwa/web/routers/olas/general.py

@@ -0,0 +1,29 @@
+"""Olas General Router."""
+
+import logging
+
+from fastapi import APIRouter, Depends
+
+from iwa.web.dependencies import verify_auth
+
+logger = logging.getLogger(__name__)
+router = APIRouter(tags=["olas"])
+
+
+@router.get(
+    "/price",
+    summary="Get OLAS Price",
+    description="Get the current price of OLAS token in EUR from CoinGecko.",
+)
+def get_olas_price(auth: bool = Depends(verify_auth)):
+    """Get current OLAS token price in EUR from CoinGecko."""
+    try:
+        from iwa.core.pricing import PriceService
+
+        price_service = PriceService()
+        price = price_service.get_token_price("autonolas", "eur")
+
+        return {"price_eur": price, "symbol": "OLAS"}
+    except Exception as e:
+        logger.error(f"Error fetching OLAS price: {e}")
+        return {"price_eur": None, "symbol": "OLAS", "error": str(e)}