golem-vm-provider 0.1.24__py3-none-any.whl → 0.1.27__py3-none-any.whl

{golem_vm_provider-0.1.24.dist-info → golem_vm_provider-0.1.27.dist-info}/METADATA

@@ -1,29 +1,30 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.24
+Version: 0.1.27
 Summary: VM on Golem Provider Node - Run your own provider node to offer VMs on the Golem Network
 Keywords: golem,vm,provider,cloud,decentralized
 Author: Phillip Jensen
 Author-email: phillip+vm-on-golem@golemgrid.com
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.13,<4.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: System Administrators
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: System :: Distributed Computing
 Requires-Dist: aiohttp (>=3.8.1,<4.0.0)
 Requires-Dist: colorlog (>=6.8.0,<7.0.0)
 Requires-Dist: cryptography (>=3.4.7,<4.0.0)
-Requires-Dist: eth-account (>=0.8.0,<0.9.0)
-Requires-Dist: fastapi (>=0.68.0,<0.69.0)
+Requires-Dist: dependency-injector (>=4.41.0,<5.0.0)
+Requires-Dist: eth-account (>=0.13.6,<0.14.0)
+Requires-Dist: fastapi (>=0.103.0,<0.104.0)
+Requires-Dist: golem-base-sdk (==0.1.0)
+Requires-Dist: httpx (>=0.23.0,<0.24.0)
 Requires-Dist: psutil (>=5.9.0,<6.0.0)
-Requires-Dist: pydantic (>=1.8.2,<2.0.0)
+Requires-Dist: pydantic (>=2.4.0,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.3.0,<4.0.0)
 Requires-Dist: python-multipart (>=0.0.5,<0.0.6)
@@ -31,7 +32,9 @@ Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: rich (>=13.7.0,<14.0.0)
 Requires-Dist: setuptools (>=69.0.3,<70.0.0)
+Requires-Dist: typer (>=0.4.0,<0.5.0)
 Requires-Dist: uvicorn (>=0.15.0,<0.16.0)
+Requires-Dist: web3 (==7.13.0)
 Project-URL: Homepage, https://github.com/cryptobench/vm-on-golem
 Project-URL: Repository, https://github.com/cryptobench/vm-on-golem
 Description-Content-Type: text/markdown
@@ -273,7 +276,11 @@ Response:
 ### Starting the Provider
 
 ```bash
-poetry run python run.py
+# To run in production mode
+poetry run golem-provider start
+
+# To run in development mode
+poetry run golem-provider dev
 ```
 
 The provider will:

golem_vm_provider-0.1.27.dist-info/RECORD

@@ -0,0 +1,38 @@
+provider/__init__.py,sha256=HO1fkPpZqPO3z8O8-eVIyx8xXSMIVuTR_b1YF0RtXOg,45
+provider/api/__init__.py,sha256=ssX1ugDqEPt8Fn04IymgmG-Ev8PiXLsCSaiZVvHQnec,344
+provider/api/models.py,sha256=hTQYzVZHJ-SD_pIpoV0KbPUghR-PUY9YKyUlETstwuQ,3567
+provider/api/routes.py,sha256=0_bh3Oh_5f__9wX6Fqb2Hray4YZAStzmlienyV__Sbs,5459
+provider/config.py,sha256=9POtsNbRYDcVW1XGTv6szosKOR5h-41-lHXnJ2_5coM,17856
+provider/container.py,sha256=u8A1FuG2targtBBqQlSiPW1yCTOm1tbrRQh8sIHstiM,2442
+provider/discovery/__init__.py,sha256=Y6o8RxGevBpuQS3k32y-zSVbP6HBXG3veBl9ElVPKaU,349
+provider/discovery/advertiser.py,sha256=2-khnnzaaftiV1QfJoILkzX-ipa3m1PxSdNd7gy7Y0A,5672
+provider/discovery/golem_base_advertiser.py,sha256=qXIiQ0nvn7ytb6LR9KaMNFwGSE2HTY4XtMlkkAG7pj4,6093
+provider/discovery/golem_base_utils.py,sha256=xk7vznhMgzrn0AuGyk6-9N9ukp9oPdBbbk1RI-sVjp0,607
+provider/discovery/resource_monitor.py,sha256=AmiEc7yBGEGXCunQ-QKmVgosDX3gOhK1Y58LJZXrwAs,949
+provider/discovery/resource_tracker.py,sha256=MP7IXd3aIMsjB4xz5Oj9zFDTEnvrnw-Cyxpl33xcJcc,6006
+provider/discovery/service.py,sha256=qU_fa8znPDNk-fQZ6Z3x6HDTbopK6RgfC_D8rixqBmY,709
+provider/main.py,sha256=rC9WK3adULZ2hAQHdMgubBe-s23TXJuJnZrNySiJZSA,6081
+provider/network/port_verifier.py,sha256=3l6WNwBHydggJRFYkAsuBp1eCxaU619kjWuM-zSVj2o,13267
+provider/security/ethereum.py,sha256=EwPZj4JR8OEpto6LhKjuuT3Z9pBX6P7-UQaqJtqFkYQ,1242
+provider/security/faucet.py,sha256=O2DgP3bIrRUm9tdLCdgnda9em0rPyeW42sWhO1EQJaA,5363
+provider/service.py,sha256=Bc7jOemhqgz9adaWOFLbWum8HFY7fmf1Mmx50-Ygwuo,2389
+provider/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+provider/utils/ascii_art.py,sha256=ykBFsztk57GIiz1NJ-EII5UvN74iECqQL4h9VmiW6Z8,3161
+provider/utils/logging.py,sha256=VV3oTYSRT8hUejtXLuua1M6kCHmIJgPspIkzsUVhYW0,1920
+provider/utils/port_display.py,sha256=u1HWQFA2kPbsM-TnsQfL6Hr4KmjIZWZfsjoxarHpbW0,11981
+provider/utils/retry.py,sha256=1p12vZZkfotRDnv56jDXWG4W7jgGuZfRSXcbZC_ytTI,2935
+provider/utils/setup.py,sha256=Z5dLuBQkb5vdoQsu1HJZwXmu9NWsiBYJ7Vq9-C-_tY8,2932
+provider/vm/__init__.py,sha256=LJL504QGbqZvBbMN3G9ixMgAwvOWAKW37zUm_EiaW9M,508
+provider/vm/cloud_init.py,sha256=E5dDH7dqStRcJNDfbarBBe83-c9N63W8B5ycIrHI8eU,4627
+provider/vm/models.py,sha256=hNeXgOnXWyeSiYt07Pdks0B20cDi_VC8jV-tCxULNng,6350
+provider/vm/multipass.py,sha256=rjO3GtuS4O_wXyYXSUiDGWYtQV2LpGxm6kITrA-ghBQ,617
+provider/vm/multipass_adapter.py,sha256=1s3PtiaRmRxqOQJU651pIgZW1kwnZtl-Tclkk341TLM,10104
+provider/vm/name_mapper.py,sha256=14nKfCjJ1WkXfC4vnCYIxNGQUwcl2vcxrJYUAz4fL40,4073
+provider/vm/port_manager.py,sha256=iYSwjTjD_ziOhG8aI7juKHw1OwwRUTJQyQoRUNQvz9w,12514
+provider/vm/provider.py,sha256=A7QN89EJjcSS40_SmKeinG1Jp_NGffJaLse-XdKciAs,1164
+provider/vm/proxy_manager.py,sha256=n4NTsyz2rtrvjtf_ceKBk-g2q_mzqPwruB1q7UlQVBc,14928
+provider/vm/service.py,sha256=VpWhUuVtsmz9yUIiCT7XSoA0aA89I_4-g3JKbaGrryw,3651
+golem_vm_provider-0.1.27.dist-info/METADATA,sha256=1CBJwjPlc1l3qSLH0eICzslk3nH0RbuaTV3cjgz8658,10793
+golem_vm_provider-0.1.27.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.27.dist-info/entry_points.txt,sha256=iFUajRxfViYkFcPMPv2EIjYm-BLOp86LJj_IjCwwZUw,74
+golem_vm_provider-0.1.27.dist-info/RECORD,,

{golem_vm_provider-0.1.24.dist-info → golem_vm_provider-0.1.27.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any

golem_vm_provider-0.1.27.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+dev=provider.main:dev
+golem-provider=provider.main:cli
+

provider/api/models.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 from typing import Dict, Optional, List, Any
 from datetime import datetime
 
@@ -11,21 +11,21 @@ logger = setup_logger(__name__)
 class CreateVMRequest(BaseModel):
     """Request model for creating a VM."""
     name: str = Field(..., min_length=3, max_length=64,
-                      regex="^[a-z0-9][a-z0-9-]*[a-z0-9]$")
+                      pattern="^[a-z0-9][a-z0-9-]*[a-z0-9]$")
     size: Optional[VMSize] = None
     resources: Optional[VMResources] = None
     image: str = Field(default="24.04")  # Ubuntu 24.04 LTS
-    ssh_key: str = Field(..., regex="^(ssh-rsa|ssh-ed25519) ",
+    ssh_key: str = Field(..., pattern="^(ssh-rsa|ssh-ed25519) ",
                          description="SSH public key for VM access")
 
-    @validator("name")
+    @field_validator("name")
     def validate_name(cls, v: str) -> str:
         """Validate VM name."""
         if "--" in v:
             raise ValueError("VM name cannot contain consecutive hyphens")
         return v
 
-    @validator("resources", pre=True)
+    @field_validator("resources", mode='before')
     def validate_resources(cls, v: Optional[Dict[str, Any]], values: Dict[str, Any]) -> VMResources:
         """Validate and set resources."""
         logger.debug(f"Validating resources input: {v}")
@@ -43,10 +43,10 @@ class CreateVMRequest(BaseModel):
                 return v
 
             # If size provided, use that
-            if "size" in values and values["size"] is not None:
-                result = VMResources.from_size(values["size"])
+            if "size" in values.data and values.data["size"] is not None:
+                result = VMResources.from_size(values.data["size"])
                 logger.debug(
-                    f"Created resources from size {values['size']}: {result}")
+                    f"Created resources from size {values.data['size']}: {result}")
                 return result
 
             # Only use defaults if nothing provided
@@ -57,7 +57,7 @@ class CreateVMRequest(BaseModel):
         except Exception as e:
             logger.error(f"Error validating resources: {e}")
             logger.error(f"Input value: {v}")
-            logger.error(f"Values dict: {values}")
+            logger.error(f"Values dict: {values.data}")
             raise ValueError(f"Invalid resource configuration: {str(e)}")
 
 
@@ -82,7 +82,7 @@ class VMResponse(BaseModel):
 class AddSSHKeyRequest(BaseModel):
     """Request model for adding SSH key."""
     name: str = Field(..., min_length=1, max_length=64)
-    public_key: str = Field(..., regex="^(ssh-rsa|ssh-ed25519) ")
+    public_key: str = Field(..., pattern="^(ssh-rsa|ssh-ed25519) ")
 
 
 class ErrorResponse(BaseModel):

provider/api/routes.py

@@ -3,150 +3,144 @@ from typing import List
 from pathlib import Path
 from fastapi import APIRouter, HTTPException, Request
 
-from ..config import settings
-from ..utils.logging import setup_logger, PROCESS, SUCCESS
+from dependency_injector.wiring import inject, Provide
+from fastapi import APIRouter, HTTPException, Depends
+
+from ..config import Settings
+from ..container import Container
+from ..utils.logging import setup_logger
 from ..utils.ascii_art import vm_creation_animation, vm_status_change
-from ..vm.models import VMInfo, VMStatus, VMAccessInfo, VMConfig, VMResources
+from ..vm.models import VMInfo, VMAccessInfo, VMConfig, VMResources, VMNotFoundError
 from .models import CreateVMRequest
-from ..vm.multipass import MultipassProvider, MultipassError
+from ..vm.service import VMService
+from ..vm.multipass_adapter import MultipassError
 
 logger = setup_logger(__name__)
 router = APIRouter()
 
+
 @router.post("/vms", response_model=VMInfo)
-async def create_vm(request: CreateVMRequest, req: Request) -> VMInfo:
+@inject
+async def create_vm(
+    request: CreateVMRequest,
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+    settings: Settings = Depends(Provide[Container.config]),
+) -> VMInfo:
     """Create a new VM."""
     try:
         logger.info(f"📥 Received VM creation request for '{request.name}'")
         
-        # Determine resources based on request
-        resources = request.resources
-        if resources is None:
-            # This shouldn't happen due to validator, but just in case
-            resources = VMResources(cpu=1, memory=1, storage=10)
-            
-        logger.info(f"📥 Using resources: {resources.cpu} CPU, {resources.memory}GB RAM, {resources.storage}GB storage")
+        resources = request.resources or VMResources()
         
-        # Validate against minimum requirements
-        if resources.cpu < settings.MIN_CPU_CORES:
-            logger.error(f"❌ CPU cores {resources.cpu} below minimum {settings.MIN_CPU_CORES}")
-            raise HTTPException(400, f"Minimum CPU cores required: {settings.MIN_CPU_CORES}")
-        if resources.memory < settings.MIN_MEMORY_GB:
-            logger.error(f"❌ Memory {resources.memory}GB below minimum {settings.MIN_MEMORY_GB}GB")
-            raise HTTPException(400, f"Minimum memory required: {settings.MIN_MEMORY_GB}GB")
-        if resources.storage < settings.MIN_STORAGE_GB:
-            logger.error(f"❌ Storage {resources.storage}GB below minimum {settings.MIN_STORAGE_GB}GB")
-            raise HTTPException(400, f"Minimum storage required: {settings.MIN_STORAGE_GB}GB")
-
-        # Check and allocate resources
-        logger.process("🔄 Allocating resources")
-        if not await req.app.state.resource_tracker.allocate(resources):
-            logger.error("❌ Insufficient resources available")
-            raise HTTPException(400, "Insufficient resources available on provider")
-        
-        try:
-            # Create VM config
-            config = VMConfig(
-                name=request.name,
-                image=request.image or settings.DEFAULT_VM_IMAGE,
-                resources=resources,
-                ssh_key=request.ssh_key
-            )
-            
-            # Create VM
-            logger.process(f"🔄 Creating VM with config: {config}")
-            vm_info = await req.app.state.provider.create_vm(config)
-
-            # Show success message
-            await vm_creation_animation(request.name)
-            return vm_info
-        except Exception as e:
-            # If VM creation fails, deallocate resources
-            logger.warning("⚠️ VM creation failed, deallocating resources")
-            await req.app.state.resource_tracker.deallocate(resources)
-            raise
+        # Create VM config
+        config = VMConfig(
+            name=request.name,
+            image=request.image or settings["DEFAULT_VM_IMAGE"],
+            resources=resources,
+            ssh_key=request.ssh_key
+        )
         
+        vm_info = await vm_service.create_vm(config)
+        await vm_creation_animation(request.name)
+        return vm_info
     except MultipassError as e:
         logger.error(f"Failed to create VM: {e}")
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail="An unexpected error occurred")
+
 
 @router.get("/vms", response_model=List[VMInfo])
-async def list_vms(req: Request) -> List[VMInfo]:
+@inject
+async def list_vms(
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+) -> List[VMInfo]:
     """List all VMs."""
     try:
         logger.info("📋 Listing all VMs")
-        vms = []
-        for vm_id in req.app.state.resource_tracker.get_allocated_vms():
-            vm_info = await req.app.state.provider.get_vm_status(vm_id)
-            vms.append(vm_info)
-        return vms
+        return await vm_service.list_vms()
     except MultipassError as e:
         logger.error(f"Failed to list VMs: {e}")
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail="An unexpected error occurred")
+
 
 @router.get("/vms/{requestor_name}", response_model=VMInfo)
-async def get_vm_status(requestor_name: str, req: Request) -> VMInfo:
+@inject
+async def get_vm_status(
+    requestor_name: str,
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+) -> VMInfo:
     """Get VM status."""
     try:
         logger.info(f"🔍 Getting status for VM '{requestor_name}'")
-        status = await req.app.state.provider.get_vm_status(requestor_name)
+        status = await vm_service.get_vm_status(requestor_name)
         vm_status_change(requestor_name, status.status.value)
         return status
+    except VMNotFoundError as e:
+        logger.error(f"VM not found: {e}")
+        raise HTTPException(status_code=404, detail=str(e))
     except MultipassError as e:
         logger.error(f"Failed to get VM status: {e}")
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail="An unexpected error occurred")
+
 
 @router.get("/vms/{requestor_name}/access", response_model=VMAccessInfo)
-async def get_vm_access(requestor_name: str, req: Request) -> VMAccessInfo:
+@inject
+async def get_vm_access(
+    requestor_name: str,
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+    settings: Settings = Depends(Provide[Container.config]),
+) -> VMAccessInfo:
     """Get VM access information."""
     try:
-        # Get VM info
-        vm = await req.app.state.provider.get_vm_status(requestor_name)
+        vm = await vm_service.get_vm_status(requestor_name)
         if not vm:
             raise HTTPException(404, "VM not found")
         
-        # Get multipass name from mapper
-        multipass_name = await req.app.state.provider.name_mapper.get_multipass_name(requestor_name)
+        multipass_name = await vm_service.name_mapper.get_multipass_name(requestor_name)
         if not multipass_name:
             raise HTTPException(404, "VM mapping not found")
         
-        # Return access info with both names
         return VMAccessInfo(
-            ssh_host=settings.PUBLIC_IP or "localhost",
-            ssh_port=vm.ssh_port or 22,
+            ssh_host=settings["PUBLIC_IP"] or "localhost",
+            ssh_port=vm.ssh_port,
             vm_id=requestor_name,
             multipass_name=multipass_name
         )
-        
     except MultipassError as e:
         logger.error(f"Failed to get VM access info: {e}")
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail="An unexpected error occurred")
+
 
 @router.delete("/vms/{requestor_name}")
-async def delete_vm(requestor_name: str, req: Request) -> None:
-    """Delete a VM.
-    
-    Args:
-        requestor_name: Name of the VM as provided by requestor
-    """
+@inject
+async def delete_vm(
+    requestor_name: str,
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+) -> None:
+    """Delete a VM."""
     try:
         logger.process(f"🗑️  Deleting VM '{requestor_name}'")
-        
-        # Get multipass name from mapper
-        multipass_name = await req.app.state.provider.name_mapper.get_multipass_name(requestor_name)
-        if not multipass_name:
-            logger.warning(f"No multipass name found for VM '{requestor_name}' (may have been already deleted)")
-            return
-            
-        try:
-            vm_status_change(requestor_name, "STOPPING", "Cleanup in progress")
-            await req.app.state.provider.delete_vm(requestor_name)
-            vm_status_change(requestor_name, "TERMINATED", "Cleanup complete")
-            logger.success(f"✨ Successfully deleted VM '{requestor_name}'")
-        except MultipassError as e:
-            logger.error(f"Failed to delete VM: {e}")
-            raise HTTPException(500, str(e))
-            
-    except Exception as e:
+        vm_status_change(requestor_name, "STOPPING", "Cleanup in progress")
+        await vm_service.delete_vm(requestor_name)
+        vm_status_change(requestor_name, "TERMINATED", "Cleanup complete")
+        logger.success(f"✨ Successfully deleted VM '{requestor_name}'")
+    except VMNotFoundError as e:
+        logger.error(f"VM not found: {e}")
+        raise HTTPException(status_code=404, detail=str(e))
+    except MultipassError as e:
         logger.error(f"Failed to delete VM: {e}")
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail="An unexpected error occurred")

provider/config.py

@@ -2,8 +2,10 @@ import os
 from pathlib import Path
 from typing import Optional
 import uuid
+import socket
 
-from pydantic import BaseSettings, validator, Field
+from pydantic_settings import BaseSettings
+from pydantic import field_validator, Field
 from .utils.logging import setup_logger
 
 logger = setup_logger(__name__)
@@ -16,14 +18,29 @@ class Settings(BaseSettings):
     DEBUG: bool = True
     HOST: str = "0.0.0.0"
     PORT: int = 7466
+    SKIP_PORT_VERIFICATION: bool = False
+    ENVIRONMENT: str = "production"
+
+    @property
+    def DEV_MODE(self) -> bool:
+        return self.ENVIRONMENT == "development"
+
+    @field_validator("SKIP_PORT_VERIFICATION", mode='before')
+    def set_skip_verification(cls, v: bool, values: dict) -> bool:
+        """Set skip verification based on debug mode."""
+        return v or values.data.get("DEBUG", False)
 
     # Provider Settings
-    PROVIDER_ID: str = ""  # Will be set from Ethereum identity
     PROVIDER_NAME: str = "golem-provider"
     PROVIDER_COUNTRY: str = "SE"
     ETHEREUM_KEY_DIR: str = ""
-
-    @validator("ETHEREUM_KEY_DIR", pre=True)
+    ETHEREUM_PRIVATE_KEY: Optional[str] = None
+    PROVIDER_ID: str = ""  # Will be set from Ethereum identity
+    FAUCET_URL: str = "https://ethwarsaw.holesky.golemdb.io/faucet"
+    CAPTCHA_URL: str = "https://cap.gobas.me"
+    CAPTCHA_API_KEY: str = "05381a2cef5e"
+ 
+    @field_validator("ETHEREUM_KEY_DIR", mode='before')
     def resolve_key_dir(cls, v: str) -> str:
         """Resolve Ethereum key directory path."""
         if not v:
@@ -33,24 +50,56 @@ class Settings(BaseSettings):
             path = Path.home() / path
         return str(path)
 
-    @validator("PROVIDER_ID", always=True)
-    def get_or_create_provider_id(cls, v: str, values: dict) -> str:
-        """Get or create provider ID from Ethereum identity."""
+    @field_validator("ETHEREUM_PRIVATE_KEY", mode='before')
+    def get_private_key(cls, v: Optional[str], values: dict) -> str:
+        """Get private key from key file if not provided."""
         from provider.security.ethereum import EthereumIdentity
 
-        # If ID provided in env, use it
         if v:
             return v
-
-        # Get ID from Ethereum identity
-        key_dir = values.get("ETHEREUM_KEY_DIR")
+        
+        key_dir = values.data.get("ETHEREUM_KEY_DIR")
         identity = EthereumIdentity(key_dir)
-        return identity.get_or_create_identity()
-
+        _, private_key = identity.get_or_create_identity()
+        return private_key
+
+    @field_validator("PROVIDER_ID", mode='before')
+    def get_provider_id(cls, v: str, values: dict) -> str:
+        """Get provider ID from private key."""
+        from eth_account import Account
+
+        private_key = values.data.get("ETHEREUM_PRIVATE_KEY")
+        if not private_key:
+            raise ValueError("ETHEREUM_PRIVATE_KEY is not set")
+
+        acct = Account.from_key(private_key)
+        provider_id_from_key = acct.address
+
+        # If ID was provided via env, warn if it doesn't match
+        if v and v != provider_id_from_key:
+            logger.warning(
+                f"Provider ID from env ('{v}') does not match ID from key file ('{provider_id_from_key}'). "
+                "Using ID from key file."
+            )
+        
+        return provider_id_from_key
+ 
+    @field_validator("PROVIDER_NAME", mode='before')
+    def set_provider_name(cls, v: str, values: dict) -> str:
+        """Prefix provider name with DEVMODE if in development."""
+        if values.data.get("ENVIRONMENT") == "development":
+            return f"DEVMODE-{v}"
+        return v
+ 
     # Discovery Service Settings
     DISCOVERY_URL: str = "http://195.201.39.101:9001"
+    ADVERTISER_TYPE: str = "golem_base"  # or "discovery_server"
     ADVERTISEMENT_INTERVAL: int = 240  # seconds
 
+    # Golem Base Settings
+    GOLEM_BASE_RPC_URL: str = "https://ethwarsaw.holesky.golemdb.io/rpc"
+    GOLEM_BASE_WS_URL: str = "wss://ethwarsaw.holesky.golemdb.io/rpc/ws"
+
     # VM Settings
     MAX_VMS: int = 10
     DEFAULT_VM_IMAGE: str = "ubuntu:24.04"
@@ -59,7 +108,7 @@ class Settings(BaseSettings):
     CLOUD_INIT_DIR: str = ""
     CLOUD_INIT_FALLBACK_DIR: str = ""  # Will be set to a temp directory if needed
 
-    @validator("CLOUD_INIT_DIR", pre=True)
+    @field_validator("CLOUD_INIT_DIR", mode='before')
     def resolve_cloud_init_dir(cls, v: str) -> str:
         """Resolve and create cloud-init directory path."""
         import platform
@@ -142,7 +191,7 @@ class Settings(BaseSettings):
             logger.error(f"Failed to create cloud-init directory at {path}: {e}")
             raise ValueError(f"Failed to create cloud-init directory: {e}")
 
-    @validator("VM_DATA_DIR", pre=True)
+    @field_validator("VM_DATA_DIR", mode='before')
     def resolve_vm_data_dir(cls, v: str) -> str:
         """Resolve and create VM data directory path."""
         if not v:
@@ -161,7 +210,7 @@ class Settings(BaseSettings):
             
         return str(path)
 
-    @validator("SSH_KEY_DIR", pre=True)
+    @field_validator("SSH_KEY_DIR", mode='before')
     def resolve_ssh_key_dir(cls, v: str) -> str:
         """Resolve and create SSH key directory path with secure permissions."""
         if not v:
@@ -200,7 +249,7 @@ class Settings(BaseSettings):
         description="Path to multipass binary"
     )
 
-    @validator("MULTIPASS_BINARY_PATH")
+    @field_validator("MULTIPASS_BINARY_PATH")
     def detect_multipass_path(cls, v: str) -> str:
         """Detect and validate Multipass binary path."""
         import platform
@@ -325,7 +374,7 @@ class Settings(BaseSettings):
     PROXY_STATE_DIR: str = ""
     PUBLIC_IP: Optional[str] = None
 
-    @validator("PROXY_STATE_DIR", pre=True)
+    @field_validator("PROXY_STATE_DIR", mode='before')
     def resolve_proxy_state_dir(cls, v: str) -> str:
         """Resolve and create proxy state directory path."""
         if not v:
@@ -344,16 +393,47 @@ class Settings(BaseSettings):
             
         return str(path)
 
-    @validator("PUBLIC_IP", pre=True)
-    def get_public_ip(cls, v: Optional[str]) -> Optional[str]:
+    @field_validator("PUBLIC_IP", mode='before')
+    def get_public_ip(cls, v: Optional[str], values: dict) -> Optional[str]:
         """Get public IP if set to 'auto'."""
+        if values.data.get("ENVIRONMENT") == "development":
+            try:
+                hostname = socket.gethostname()
+                ips = socket.gethostbyname_ex(hostname)[2]
+                local_ips = [ip for ip in ips if not ip.startswith("127.")]
+                if local_ips:
+                    ip = local_ips[0]
+                    logger.info(f"Found local IP for development: {ip}")
+                    return ip
+            except socket.gaierror:
+                pass
+
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            try:
+                s.connect(('8.8.8.8', 80))
+                IP = s.getsockname()[0]
+                if IP:
+                    logger.info(f"Found local IP for development: {IP}")
+                    return IP
+            except Exception:
+                pass
+            finally:
+                s.close()
+
+            raise ValueError("Could not determine local IP address in development mode. "
+                             "Please ensure you have a valid network connection.")
         if v == "auto":
             try:
                 import requests
                 response = requests.get("https://api.ipify.org")
-                return response.text.strip()
+                ip = response.text.strip()
+                logger.info(f"Found public IP: {ip}")
+                return ip
             except Exception:
                 return None
+        
+        if v:
+            logger.info(f"Using manually provided IP: {v}")
         return v
 
     class Config: