golem-vm-provider 0.1.23__tar.gz → 0.1.26__tar.gz

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/PKG-INFO

@@ -1,29 +1,29 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.23
+Version: 0.1.26
 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: 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 +31,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

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/provider/api/models.py

@@ -11,11 +11,11 @@ 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")
@@ -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):

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/provider/config.py

@@ -3,7 +3,8 @@ from pathlib import Path
 from typing import Optional
 import uuid
 
-from pydantic import BaseSettings, validator, Field
+from pydantic_settings import BaseSettings
+from pydantic import validator, Field
 from .utils.logging import setup_logger
 
 logger = setup_logger(__name__)
@@ -16,13 +17,28 @@ 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"
+
+    @validator("SKIP_PORT_VERIFICATION", always=True)
+    def set_skip_verification(cls, v: bool, values: dict) -> bool:
+        """Set skip verification based on debug mode."""
+        return v or values.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 = ""
-
+    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"
+ 
     @validator("ETHEREUM_KEY_DIR", pre=True)
     def resolve_key_dir(cls, v: str) -> str:
         """Resolve Ethereum key directory path."""
@@ -33,24 +49,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."""
+    @validator("ETHEREUM_PRIVATE_KEY", always=True)
+    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")
         identity = EthereumIdentity(key_dir)
-        return identity.get_or_create_identity()
+        _, private_key = identity.get_or_create_identity()
+        return private_key
 
+    @validator("PROVIDER_ID", always=True)
+    def get_provider_id(cls, v: str, values: dict) -> str:
+        """Get provider ID from private key."""
+        from eth_account import Account
+
+        private_key = values.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
+ 
+    @validator("PROVIDER_NAME", always=True)
+    def set_provider_name(cls, v: str, values: dict) -> str:
+        """Prefix provider name with DEVMODE if in development."""
+        if values.get("ENVIRONMENT") == "development":
+            return f"DEVMODE-{v}"
+        return v
+ 
     # Discovery Service Settings
     DISCOVERY_URL: str = "http://195.201.39.101:9001"
+    DISCOVERY_DRIVER: str = "golem-base" # or "legacy"
     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"
@@ -345,9 +393,19 @@ class Settings(BaseSettings):
         return str(path)
 
     @validator("PUBLIC_IP", pre=True)
-    def get_public_ip(cls, v: Optional[str]) -> Optional[str]:
+    def get_public_ip(cls, v: Optional[str], values: dict) -> Optional[str]:
         """Get public IP if set to 'auto'."""
         if v == "auto":
+            if values.get("ENVIRONMENT") == "development":
+                import socket
+                try:
+                    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+                    s.connect(("8.8.8.8", 80))
+                    local_ip = s.getsockname()[0]
+                    s.close()
+                    return local_ip
+                except Exception:
+                    return "127.0.0.1"
             try:
                 import requests
                 response = requests.get("https://api.ipify.org")

golem_vm_provider-0.1.26/provider/discovery/golem_base_advertiser.py

@@ -0,0 +1,129 @@
+import asyncio
+from typing import Optional
+
+from golem_base_sdk import GolemBaseClient, GolemBaseCreate, GolemBaseUpdate, GolemBaseDelete, Annotation
+from .golem_base_utils import get_provider_entity_keys
+from ..config import settings
+from ..utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class GolemBaseAdvertiser:
+    """Advertise available resources to the Golem Base network."""
+
+    def __init__(self, resource_tracker: "ResourceTracker"):
+        self.resource_tracker = resource_tracker
+        self.client: Optional[GolemBaseClient] = None
+        self._stop_event = asyncio.Event()
+
+    async def initialize(self):
+        """Initialize the advertiser."""
+        private_key_hex = settings.ETHEREUM_PRIVATE_KEY.replace("0x", "")
+        private_key_bytes = bytes.fromhex(private_key_hex)
+        self.client = await GolemBaseClient.create(
+            rpc_url=settings.GOLEM_BASE_RPC_URL,
+            ws_url=settings.GOLEM_BASE_WS_URL,
+            private_key=private_key_bytes,
+        )
+        self.resource_tracker.on_update(
+            lambda: asyncio.create_task(self.post_advertisement())
+        )
+
+    async def start_loop(self):
+        """Start advertising resources in a loop."""
+        try:
+            while not self._stop_event.is_set():
+                await self.post_advertisement()
+                await asyncio.sleep(settings.ADVERTISEMENT_INTERVAL)
+        finally:
+            await self.stop()
+
+    async def stop(self):
+        """Stop advertising resources."""
+        self._stop_event.set()
+        if self.client:
+            await self.client.disconnect()
+
+    async def post_advertisement(self):
+        """Post or update resource advertisement on the Golem Base network."""
+        if not self.client:
+            raise RuntimeError("Golem Base client not initialized")
+
+        resources = self.resource_tracker.get_available_resources()
+        if not self.resource_tracker._meets_minimum_requirements(resources):
+            logger.warning("Resources too low, skipping advertisement")
+            return
+
+        ip_address = settings.PUBLIC_IP
+        if not ip_address:
+            logger.error("Could not get public IP, skipping advertisement")
+            return
+
+        try:
+            existing_keys = await get_provider_entity_keys(self.client, settings.PROVIDER_ID)
+
+            string_annotations = [
+                Annotation(key="golem_type", value="provider"),
+                Annotation(key="golem_provider_id", value=settings.PROVIDER_ID),
+                Annotation(key="golem_ip_address", value=ip_address),
+                Annotation(key="golem_country", value=settings.PROVIDER_COUNTRY),
+                Annotation(key="golem_provider_name", value=settings.PROVIDER_NAME),
+            ]
+            numeric_annotations = [
+                Annotation(key="golem_cpu", value=resources["cpu"]),
+                Annotation(key="golem_memory", value=resources["memory"]),
+                Annotation(key="golem_storage", value=resources["storage"]),
+            ]
+
+            if len(existing_keys) > 1:
+                logger.warning(f"Found {len(existing_keys)} advertisements. Cleaning up and creating a new one.")
+                deletes = [GolemBaseDelete(entity_key=key) for key in existing_keys]
+                await self.client.delete_entities(deletes)
+                await self._create_advertisement(string_annotations, numeric_annotations)
+
+            elif len(existing_keys) == 1:
+                entity_key = existing_keys[0]
+                metadata = await self.client.get_entity_metadata(entity_key)
+                
+                current_annotations = {ann.key: ann.value for ann in metadata.numeric_annotations}
+                current_annotations.update({ann.key: ann.value for ann in metadata.string_annotations})
+
+                if (current_annotations.get("golem_cpu") == resources["cpu"] and
+                    current_annotations.get("golem_memory") == resources["memory"] and
+                    current_annotations.get("golem_storage") == resources["storage"] and
+                    current_annotations.get("golem_ip_address") == ip_address and
+                    current_annotations.get("golem_provider_name") == settings.PROVIDER_NAME):
+                    logger.info("Advertisement is up-to-date. Waiting for expiration.")
+                else:
+                    logger.info("Advertisement is outdated. Updating.")
+                    update = GolemBaseUpdate(
+                        entity_key=entity_key,
+                        data=b"",
+                        btl=settings.ADVERTISEMENT_INTERVAL * 2,
+                        string_annotations=string_annotations,
+                        numeric_annotations=numeric_annotations,
+                    )
+                    await self.client.update_entities([update])
+                    logger.info(f"Updated advertisement. Entity key: {entity_key}")
+
+            else: # No existing keys
+                await self._create_advertisement(string_annotations, numeric_annotations)
+
+        except Exception as e:
+            logger.error(f"Failed to post or update advertisement on Golem Base: {e}")
+
+    async def _create_advertisement(self, string_annotations, numeric_annotations):
+        """Helper to create a new advertisement."""
+        entity = GolemBaseCreate(
+            data=b"",
+            btl=settings.ADVERTISEMENT_INTERVAL * 2,
+            string_annotations=string_annotations,
+            numeric_annotations=numeric_annotations,
+        )
+        receipts = await self.client.create_entities([entity])
+        if receipts:
+            receipt = receipts[0]
+            logger.info(f"Posted new advertisement. Entity key: {receipt.entity_key}")
+        else:
+            logger.error("Failed to post advertisement: no receipt received")

golem_vm_provider-0.1.26/provider/discovery/golem_base_utils.py

@@ -0,0 +1,10 @@
+from typing import List
+from golem_base_sdk import GolemBaseClient, EntityKey, QueryEntitiesResult, GenericBytes
+from ..config import settings
+
+async def get_provider_entity_keys(client: GolemBaseClient, provider_id: str) -> List[EntityKey]:
+    """Get all entity keys for a given provider ID."""
+    query = f'golem_provider_id="{provider_id}"'
+    results: list[QueryEntitiesResult] = await client.query_entities(query)
+    # The entity_key from query_entities is a hex string, convert it to an EntityKey object
+    return [EntityKey(GenericBytes.from_hex_string(result.entity_key)) for result in results]

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/provider/main.py

@@ -1,6 +1,8 @@
+from .api import routes
 import asyncio
 import os
 from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
 from typing import Optional
 
 from .config import settings
@@ -8,12 +10,23 @@ from .utils.logging import setup_logger, PROCESS, SUCCESS
 from .utils.ascii_art import startup_animation
 from .discovery.resource_tracker import ResourceTracker
 from .discovery.advertiser import ResourceAdvertiser
+from .discovery.golem_base_advertiser import GolemBaseAdvertiser
 from .vm.multipass import MultipassProvider
 from .vm.port_manager import PortManager
+from .security.faucet import FaucetClient
 
 logger = setup_logger(__name__)
 
 app = FastAPI(title="VM on Golem Provider")
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
 
 async def setup_provider() -> None:
     """Setup and initialize the provider components."""
@@ -25,67 +38,73 @@ async def setup_provider() -> None:
 
         # Create provider with resource tracker and temporary port manager
         logger.process("🔄 Initializing VM provider...")
-        provider = MultipassProvider(resource_tracker, port_manager=None)  # Will be set later
-        
+        provider = MultipassProvider(
+            resource_tracker, port_manager=None)  # Will be set later
+
         try:
             # Initialize provider (without port operations)
             await asyncio.wait_for(provider.initialize(), timeout=30)
-            
+
             # Store provider reference
             app.state.provider = provider
             app.state.proxy_manager = provider.proxy_manager
-            
-            # Restore proxy configurations first
-            logger.process("🔄 Restoring proxy configurations...")
-            await app.state.proxy_manager._load_state()
-            
-            # Now initialize port manager with knowledge of restored proxies
+
+            # Initialize port manager first to verify all ports
             logger.process("🔄 Initializing port manager...")
             port_manager = PortManager(
                 start_port=settings.PORT_RANGE_START,
                 end_port=settings.PORT_RANGE_END,
                 discovery_port=settings.PORT,
-                existing_ports=app.state.proxy_manager.get_active_ports()
+                skip_verification=settings.SKIP_PORT_VERIFICATION
             )
-            
+
             if not await port_manager.initialize():
                 raise RuntimeError("Port verification failed")
-            
-            # Update provider and proxy manager with verified port manager
+
+            # Store port manager references
             app.state.port_manager = port_manager
             provider.port_manager = port_manager
             app.state.proxy_manager.port_manager = port_manager
-            
+
+            # Now restore proxy configurations using only verified ports
+            logger.process("🔄 Restoring proxy configurations...")
+            await app.state.proxy_manager._load_state()
+
         except asyncio.TimeoutError:
             logger.error("Provider initialization timed out")
             raise
         except Exception as e:
             logger.error(f"Failed to initialize provider: {e}")
             raise
-        
-        # Create and start advertiser in background
-        logger.process("🔄 Starting resource advertiser...")
-        advertiser = ResourceAdvertiser(
-            resource_tracker=resource_tracker,
-            discovery_url=settings.DISCOVERY_URL,
-            provider_id=settings.PROVIDER_ID
-        )
-        
-        # Start advertiser in background task
-        app.state.advertiser_task = asyncio.create_task(advertiser.start())
+
+        # Create advertiser
+        logger.process("🔄 Initializing resource advertiser...")
+        if settings.DISCOVERY_DRIVER == "golem-base":
+            advertiser = GolemBaseAdvertiser(
+                resource_tracker=resource_tracker
+            )
+            await advertiser.initialize()
+        else:
+            advertiser = ResourceAdvertiser(
+                resource_tracker=resource_tracker,
+                discovery_url=settings.DISCOVERY_URL,
+                provider_id=settings.PROVIDER_ID
+            )
         app.state.advertiser = advertiser
-        
-        logger.success("✨ Provider setup complete and ready to accept requests")
+
+        logger.success(
+            "✨ Provider setup complete and ready to accept requests")
     except Exception as e:
         logger.error(f"Failed to setup provider: {e}")
         # Attempt cleanup of any initialized components
         await cleanup_provider()
         raise
 
+
 async def cleanup_provider() -> None:
     """Cleanup provider components."""
     cleanup_errors = []
-    
+
     # Stop advertiser
     if hasattr(app.state, "advertiser"):
         try:
@@ -98,7 +117,7 @@ async def cleanup_provider() -> None:
                     pass
         except Exception as e:
             cleanup_errors.append(f"Failed to stop advertiser: {e}")
-    
+
     # Cleanup proxy manager first to stop all proxy servers
     if hasattr(app.state, "proxy_manager"):
         try:
@@ -107,7 +126,7 @@ async def cleanup_provider() -> None:
             cleanup_errors.append("Proxy manager cleanup timed out")
         except Exception as e:
             cleanup_errors.append(f"Failed to cleanup proxy manager: {e}")
-    
+
     # Cleanup provider
     if hasattr(app.state, "provider"):
         try:
@@ -116,71 +135,56 @@ async def cleanup_provider() -> None:
             cleanup_errors.append("Provider cleanup timed out")
         except Exception as e:
             cleanup_errors.append(f"Failed to cleanup provider: {e}")
-    
+
     if cleanup_errors:
         error_msg = "\n".join(cleanup_errors)
         logger.error(f"Errors during cleanup:\n{error_msg}")
     else:
         logger.success("✨ Provider cleanup complete")
 
+
 @app.on_event("startup")
 async def startup_event():
     """Handle application startup."""
     try:
         # Display startup animation
         await startup_animation()
+ 
+        # Initialize provider
+        await setup_provider()
 
-        # Verify ports first
-        from .vm.port_manager import PortManager
-        from .utils.port_display import PortVerificationDisplay
-        from .config import settings
-
-        display = PortVerificationDisplay(
-            provider_port=settings.PORT,
-            port_range_start=settings.PORT_RANGE_START,
-            port_range_end=settings.PORT_RANGE_END
-        )
-        display.print_header()
-
-        # Initialize port manager
-        logger.process("🔄 Verifying port accessibility...")
-        port_manager = PortManager(
-            start_port=settings.PORT_RANGE_START,
-            end_port=settings.PORT_RANGE_END,
-            discovery_port=settings.PORT
+        # Check wallet balance and request funds if needed
+        faucet_client = FaucetClient(
+            faucet_url=settings.FAUCET_URL,
+            captcha_url=settings.CAPTCHA_URL,
+            captcha_api_key=settings.CAPTCHA_API_KEY,
         )
-        if not await port_manager.initialize():
-            logger.error("Port verification failed. Please ensure:")
-            logger.error(f"1. Port {settings.PORT} is accessible for provider access")
-            logger.error(f"2. Some ports in range {settings.PORT_RANGE_START}-{settings.PORT_RANGE_END} are accessible for VM access")
-            logger.error("3. Your firewall/router is properly configured")
-            raise RuntimeError("Port verification failed")
-
-        logger.success(f"✅ Port verification successful - {len(port_manager.verified_ports)} ports available")
-        
-        # Store port manager in app state for later use
-        app.state.port_manager = port_manager
+        await faucet_client.get_funds(settings.PROVIDER_ID)
+
+        # Post initial advertisement and start advertising loop
+        if isinstance(app.state.advertiser, GolemBaseAdvertiser):
+            await app.state.advertiser.post_advertisement()
+            app.state.advertiser_task = asyncio.create_task(app.state.advertiser.start_loop())
 
-        # Initialize provider
-        await setup_provider()
     except Exception as e:
         logger.error(f"Startup failed: {e}")
         # Ensure proper cleanup
         await cleanup_provider()
         raise
 
+
 @app.on_event("shutdown")
 async def shutdown_event():
     """Handle application shutdown."""
     await cleanup_provider()
 
 # Import routes after app creation to avoid circular imports
-from .api import routes
 app.include_router(routes.router, prefix="/api/v1")
 
 # Export app for uvicorn
 __all__ = ["app", "start"]
 
+
 def check_requirements():
     """Check if all requirements are met."""
     try:
@@ -191,12 +195,13 @@ def check_requirements():
         logger.error(f"Requirements check failed: {e}")
         return False
 
+
 async def verify_provider_port(port: int) -> bool:
     """Verify that the provider port is available for binding.
-    
+
     Args:
         port: The port to verify
-        
+
     Returns:
         bool: True if the port is available, False otherwise
     """
@@ -219,7 +224,13 @@ async def verify_provider_port(port: int) -> bool:
         logger.error("3. Your firewall allows binding to this port")
         return False
 
-def start():
+
+import typer
+
+cli = typer.Typer()
+
+@cli.command()
+def start(no_verify_port: bool = typer.Option(False, "--no-verify-port", help="Skip provider port verification.")):
     """Start the provider server."""
     import sys
     from pathlib import Path
@@ -227,15 +238,15 @@ def start():
     import uvicorn
     from .utils.logging import setup_logger
     from .config import settings
-    
+
     # Configure logging with debug mode
     logger = setup_logger(__name__, debug=True)
-    
+
     try:
         # Load environment variables from .env file
         env_path = Path(__file__).parent.parent / '.env'
         load_dotenv(dotenv_path=env_path)
-        
+
         # Log environment variables
         logger.info("Environment variables:")
         for key, value in os.environ.items():
@@ -246,18 +257,19 @@ def start():
         if not check_requirements():
             logger.error("Requirements check failed")
             sys.exit(1)
-            
+
         # Verify provider port is available
-        if not asyncio.run(verify_provider_port(settings.PORT)):
+        if not no_verify_port and not asyncio.run(verify_provider_port(settings.PORT)):
             logger.error(f"Provider port {settings.PORT} is not available")
             sys.exit(1)
-        
+
         # Configure uvicorn logging
         log_config = uvicorn.config.LOGGING_CONFIG
         log_config["formatters"]["access"]["fmt"] = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        
+
         # Run server
-        logger.process(f"🚀 Starting provider server on {settings.HOST}:{settings.PORT}")
+        logger.process(
+            f"🚀 Starting provider server on {settings.HOST}:{settings.PORT}")
         uvicorn.run(
             "provider:app",
             host=settings.HOST,
@@ -271,3 +283,6 @@ def start():
     except Exception as e:
         logger.error(f"Failed to start provider server: {e}")
         sys.exit(1)
+
+if __name__ == "__main__":
+    cli()

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/provider/security/ethereum.py

@@ -13,29 +13,25 @@ class EthereumIdentity:
         self.key_dir = Path(key_dir)
         self.key_file = self.key_dir / "provider_key.json"
         
-    def get_or_create_identity(self) -> str:
-        """Get existing provider ID or create new one from Ethereum key."""
-        # Create directory if it doesn't exist
+    def get_or_create_identity(self) -> (str, str):
+        """Get existing provider ID and private key, or create a new one."""
         self.key_dir.mkdir(parents=True, exist_ok=True)
-        self.key_dir.chmod(0o700)  # Secure permissions
-        
-        # Check for existing key
+        self.key_dir.chmod(0o700)
+
         if self.key_file.exists():
-            with open(self.key_file) as f:
+            with open(self.key_file, "r") as f:
                 key_data = json.load(f)
-                return key_data["address"]
-        
-        # Generate new key
+                return key_data["address"], key_data["private_key"]
+
         Account.enable_unaudited_hdwallet_features()
         acct = Account.create()
         
-        # Save key securely
         key_data = {
             "address": acct.address,
             "private_key": acct.key.hex()
         }
         with open(self.key_file, "w") as f:
             json.dump(key_data, f)
-        self.key_file.chmod(0o600)  # Secure permissions
+        self.key_file.chmod(0o600)
         
-        return acct.address
+        return acct.address, acct.key.hex()

golem_vm_provider-0.1.26/provider/security/faucet.py

@@ -0,0 +1,132 @@
+import asyncio
+import hashlib
+import httpx
+from typing import Optional
+
+from golem_base_sdk import GolemBaseClient
+from provider.utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class FaucetClient:
+    """A client for interacting with a Proof of Work-protected faucet."""
+
+    def __init__(self, faucet_url: str, captcha_url: str, captcha_api_key: str):
+        self.faucet_url = faucet_url
+        self.captcha_url = captcha_url
+        self.captcha_api_key = captcha_api_key
+        self.api_endpoint = f"{faucet_url}/api"
+        self.client: Optional[GolemBaseClient] = None
+
+    async def _ensure_client(self):
+        if not self.client:
+            from ..config import settings
+            private_key_hex = settings.ETHEREUM_PRIVATE_KEY.replace("0x", "")
+            private_key_bytes = bytes.fromhex(private_key_hex)
+            self.client = await GolemBaseClient.create_ro_client(
+                rpc_url=settings.GOLEM_BASE_RPC_URL,
+                ws_url=settings.GOLEM_BASE_WS_URL,
+            )
+
+    async def check_balance(self, address: str) -> Optional[float]:
+        """Check the balance of the given address."""
+        await self._ensure_client()
+        try:
+            balance_wei = await self.client.http_client().eth.get_balance(address)
+            balance_eth = self.client.http_client().from_wei(balance_wei, 'ether')
+            return float(balance_eth)
+        except Exception as e:
+            logger.error(f"Failed to check balance: {e}")
+            return None
+
+    async def get_funds(self, address: str) -> Optional[str]:
+        """Request funds from the faucet for the given address."""
+        try:
+            balance = await self.check_balance(address)
+            if balance is not None and balance > 0.01:
+                logger.info(f"Sufficient funds ({balance} ETH), skipping faucet request.")
+                return None
+
+            logger.info("Requesting funds from faucet...")
+            challenge_data = await self._get_challenge()
+            if not challenge_data:
+                return None
+
+            challenge_list = challenge_data.get("challenge")
+            token = challenge_data.get("token")
+
+            if not challenge_list or not token:
+                logger.error(f"Invalid challenge data received: {challenge_data}")
+                return None
+
+            solutions = []
+            for salt, target in challenge_list:
+                nonce = self._solve_challenge(salt, target)
+                solutions.append([salt, target, nonce])
+
+            redeemed_token = await self._redeem_solution(token, solutions)
+            if not redeemed_token:
+                return None
+
+            tx_hash = await self._request_faucet(address, redeemed_token)
+            if tx_hash:
+                logger.success(f"Successfully requested funds. Transaction hash: {tx_hash}")
+            return tx_hash
+        except Exception as e:
+            import traceback
+            logger.error(f"Failed to get funds from faucet: {e}")
+            logger.error(traceback.format_exc())
+            return None
+
+    async def _get_challenge(self) -> Optional[dict]:
+        """Get a PoW challenge from the faucet."""
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                url = f"{self.captcha_url}/{self.captcha_api_key}/api/challenge"
+                response = await client.post(url)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Failed to get PoW challenge: {e.response.text}")
+            return None
+
+    def _solve_challenge(self, salt: str, target: str) -> int:
+        """Solve the PoW challenge."""
+        target_hash = bytes.fromhex(target)
+        nonce = 0
+        while True:
+            hasher = hashlib.sha256()
+            hasher.update(f"{salt}{nonce}".encode())
+            if hasher.digest().startswith(target_hash):
+                return nonce
+            nonce += 1
+
+    async def _redeem_solution(self, token: str, solutions: list) -> Optional[str]:
+        """Redeem the PoW solution to get a CAPTCHA token."""
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                url = f"{self.captcha_url}/{self.captcha_api_key}/api/redeem"
+                response = await client.post(
+                    url,
+                    json={"token": token, "solutions": solutions}
+                )
+                response.raise_for_status()
+                return response.json().get("token")
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Failed to redeem PoW solution: {e.response.text}")
+            return None
+
+    async def _request_faucet(self, address: str, token: str) -> Optional[str]:
+        """Request funds from the faucet with the CAPTCHA token."""
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                response = await client.post(
+                    f"{self.api_endpoint}/faucet",
+                    json={"address": address, "captchaToken": token}
+                )
+                response.raise_for_status()
+                return response.json().get("txHash")
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Faucet request failed: {e.response.text}")
+            return None

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/provider/utils/port_display.py

@@ -10,17 +10,25 @@ class PortVerificationDisplay:
     
     SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
     
-    def __init__(self, provider_port: int, port_range_start: int, port_range_end: int):
+    def __init__(
+        self, 
+        provider_port: int, 
+        port_range_start: int, 
+        port_range_end: int,
+        skip_verification: bool = False
+    ):
         """Initialize the display.
         
         Args:
             provider_port: Port used for provider access
             port_range_start: Start of VM access port range
             port_range_end: End of VM access port range
+            skip_verification: Whether port verification is skipped (development mode)
         """
         self.provider_port = provider_port
         self.port_range_start = port_range_start
         self.port_range_end = port_range_end
+        self.skip_verification = skip_verification
         self.spinner_idx = 0
     
     def _update_spinner(self):
@@ -91,6 +99,13 @@ class PortVerificationDisplay:
         print("\n🔒 VM Access Ports (Required)")
         print("-------------------------")
         
+        if self.skip_verification:
+            print("\n✅ All ports available in development mode")
+            print(f"└─ Port Range: {self.port_range_start}-{self.port_range_end}")
+            print("└─ Status: Port verification skipped")
+            print("└─ Note: Configure ports before deploying to production")
+            return
+
         await self.animate_verification("Scanning VM access ports...")
         
         # Calculate progress
@@ -125,6 +140,9 @@ class PortVerificationDisplay:
             discovery_result: Verification result for discovery port
             ssh_results: Dictionary mapping SSH ports to their verification results
         """
+        if self.skip_verification:
+            return
+
         issues = []
         
         # Check discovery port
@@ -155,6 +173,9 @@ class PortVerificationDisplay:
             discovery_result: Verification result for discovery port
             ssh_results: Dictionary mapping SSH ports to their verification results
         """
+        if self.skip_verification:
+            return
+
         # Check if we have any issues
         has_issues = (
             not discovery_result.accessible or 
@@ -186,6 +207,13 @@ class PortVerificationDisplay:
             ssh_results: Dictionary mapping SSH ports to their verification results
         """
         print("\n🎯 Current Status:", end=" ")
+
+        if self.skip_verification:
+            print("Development Mode")
+            print("└─ Status: Port verification skipped")
+            print(f"└─ Available: All ports in range {self.port_range_start}-{self.port_range_end}")
+            print("└─ Note: This is for development only, configure ports in production")
+            return
         
         if discovery_result is None:
             print("Verification Failed")

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/provider/vm/models.py

@@ -57,13 +57,13 @@ class VMResources(BaseModel):
 class VMCreateRequest(BaseModel):
     """Request to create a new 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
     cpu_cores: Optional[int] = None
     memory_gb: Optional[int] = None
     storage_gb: Optional[int] = None
     image: Optional[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")
@@ -91,11 +91,11 @@ class VMCreateRequest(BaseModel):
 class VMConfig(BaseModel):
     """VM configuration."""
     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]$")
     resources: VMResources
     image: str = Field(default="24.04")  # Ubuntu 24.04 LTS
     size: Optional[VMSize] = None
-    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")
@@ -127,7 +127,7 @@ class VMInfo(BaseModel):
 class SSHKey(BaseModel):
     """SSH key information."""
     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) ")
     fingerprint: Optional[str] = None
 
 

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/provider/vm/multipass.py

@@ -198,7 +198,11 @@ class MultipassProvider(VMProvider):
                 # First allocate a verified port
                 ssh_port = self.port_manager.allocate_port(multipass_name)
                 if not ssh_port:
-                    raise MultipassError("Failed to allocate verified SSH port")
+                    if settings.DEV_MODE:
+                        logger.warning("Failed to allocate verified SSH port in dev mode, falling back to random port")
+                        ssh_port = 0  # Let the proxy manager pick a random port
+                    else:
+                        raise MultipassError("Failed to allocate verified SSH port")
 
                 # Then configure proxy with allocated port
                 success = await self.proxy_manager.add_vm(multipass_name, ip_address, port=ssh_port)

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/provider/vm/port_manager.py

@@ -24,7 +24,8 @@ class PortManager:
         state_file: Optional[str] = None,
         port_check_servers: Optional[List[str]] = None,
         discovery_port: Optional[int] = None,
-        existing_ports: Optional[Set[int]] = None
+        existing_ports: Optional[Set[int]] = None,
+        skip_verification: bool = False
     ):
         """Initialize the port manager.
 
@@ -51,6 +52,7 @@ class PortManager:
             "http://195.201.39.101:9000",  # Production servers
         ]
         self.discovery_port = discovery_port or settings.PORT
+        self.skip_verification = skip_verification
         self.port_verifier = PortVerifier(
             self.port_check_servers,
             discovery_port=self.discovery_port
@@ -76,19 +78,34 @@ class PortManager:
         display = PortVerificationDisplay(
             provider_port=self.discovery_port,
             port_range_start=self.start_port,
-            port_range_end=self.end_port
+            port_range_end=self.end_port,
+            skip_verification=self.skip_verification
         )
         display.print_header()
 
-        # Only verify ports that aren't already marked as in use
-        available_ports = set(range(self.start_port, self.end_port)) - self._existing_ports
-        ssh_ports = list(available_ports)
-        logger.info(f"Starting port verification...")
-        logger.info(f"SSH ports range: {self.start_port}-{self.end_port}")
-        logger.info(
-            f"Using port check servers: {', '.join(self.port_check_servers)}")
-
-        results = await self.port_verifier.verify_ports(ssh_ports)
+        # If verification is skipped, mark all ports as verified
+        if self.skip_verification:
+            logger.warning("⚠️  Port verification is disabled in development mode")
+            logger.warning("   All ports will be considered available")
+            logger.warning("   This should only be used for development/testing")
+            
+            # Mark all ports as verified
+            self.verified_ports = set(range(self.start_port, self.end_port))
+            
+            # In development mode, we don't need to create any results
+            # The display will handle development mode differently
+            results = {}
+        else:
+            # Verify all ports in range, including existing ones
+            ssh_ports = list(range(self.start_port, self.end_port))
+            logger.info(f"Starting port verification...")
+            logger.info(f"SSH ports range: {self.start_port}-{self.end_port}")
+            logger.info(
+                f"Using port check servers: {', '.join(self.port_check_servers)}")
+
+            # Clear existing verified ports before verification
+            self.verified_ports.clear()
+            results = await self.port_verifier.verify_ports(ssh_ports)
 
         # Add provider port as verified since we already checked it
         results[self.discovery_port] = PortVerificationResult(
@@ -140,13 +157,17 @@ class PortManager:
         # Print precise summary of current status
         display.print_summary(discovery_result, ssh_results)
 
-        if not self.verified_ports:
-            logger.error("No SSH ports were verified as accessible")
-            return False
+        if self.skip_verification:
+            logger.info(f"Port verification skipped - all {len(self.verified_ports)} ports marked as available")
+            return True
+        else:
+            if not self.verified_ports:
+                logger.error("No SSH ports were verified as accessible")
+                return False
 
-        logger.info(
-            f"Successfully verified {len(self.verified_ports)} SSH ports")
-        return True
+            logger.info(
+                f"Successfully verified {len(self.verified_ports)} SSH ports")
+            return True
 
     def _load_state(self) -> None:
         """Load port assignments from state file."""
@@ -202,7 +223,8 @@ class PortManager:
                             return port
                         else:
                             # Port is in use, remove from verified ports
-                            self.verified_ports.remove(port)
+                            if not self.skip_verification:
+                                self.verified_ports.remove(port)
                             self._used_ports.pop(vm_id)
                     except Exception as e:
                         logger.debug(f"Failed to check port {port}: {e}")
@@ -215,7 +237,8 @@ class PortManager:
             used_ports = self._get_used_ports()
 
             # Find first available verified port
-            for port in sorted(self.verified_ports):
+            ports_to_check = sorted(self.verified_ports) if not self.skip_verification else range(self.start_port, self.end_port)
+            for port in ports_to_check:
                 if port not in used_ports:
                     # Quick check if port is actually available
                     try:
@@ -229,11 +252,12 @@ class PortManager:
                             self._used_ports[vm_id] = port
                             self._save_state()
                             logger.info(
-                                f"Allocated verified port {port} for VM {vm_id}")
+                                f"Allocated port {port} for VM {vm_id}")
                             return port
                         else:
                             # Port is in use, remove from verified ports
-                            self.verified_ports.remove(port)
+                            if not self.skip_verification and port in self.verified_ports:
+                                self.verified_ports.remove(port)
                     except Exception as e:
                         logger.debug(f"Failed to check port {port}: {e}")
                         continue

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/provider/vm/proxy_manager.py

@@ -243,6 +243,13 @@ class PythonProxyManager:
                     await asyncio.sleep(delay)
                     delay *= 2  # Exponential backoff
 
+                # Check if port is verified before restoring
+                if not self.port_manager or port not in self.port_manager.verified_ports:
+                    logger.warning(f"Port {port} is not verified, skipping proxy restoration for {multipass_name}")
+                    # Remove from active ports since we can't restore it
+                    self._active_ports.pop(multipass_name, None)
+                    return False
+
                 # Attempt to create proxy
                 proxy = ProxyServer(port, vm_ip)
                 await proxy.start()
@@ -301,11 +308,12 @@ class PythonProxyManager:
         """
         try:
             # Use provided port or allocate one
-            if port is None:
-                port = self.port_manager.allocate_port(vm_id)
-                if port is None:
+            if port is None or port == 0:
+                allocated_port = self.port_manager.allocate_port(vm_id)
+                if allocated_port is None:
                     logger.error(f"Failed to allocate port for VM {vm_id}")
                     return False
+                port = allocated_port
             
             # Create and start proxy server
             proxy = ProxyServer(port, vm_ip)
@@ -320,7 +328,7 @@ class PythonProxyManager:
         except Exception as e:
             logger.error(f"Failed to configure proxy for VM {vm_id}: {e}")
             # Only deallocate if we allocated the port ourselves
-            if port is None and 'port' in locals():
+            if 'allocated_port' in locals() and allocated_port:
                 self.port_manager.deallocate_port(vm_id)
             return False
     

{golem_vm_provider-0.1.23 → golem_vm_provider-0.1.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "golem-vm-provider"
-version = "0.1.23"
+version = "0.1.26"
 description = "VM on Golem Provider Node - Run your own provider node to offer VMs on the Golem Network"
 authors = ["Phillip Jensen <phillip+vm-on-golem@golemgrid.com>"]
 readme = "README.md"
@@ -20,25 +20,30 @@ packages = [
 ]
 
 [tool.poetry.scripts]
-golem-provider = "provider.main:start"
+golem-provider = "provider.main:cli"
 
 [tool.poetry.dependencies]
-python = "^3.9"
-fastapi = "^0.68.0"
+python = "^3.13"
+fastapi = "^0.103.0"
 uvicorn = "^0.15.0"
 aiohttp = "^3.8.1"
 psutil = "^5.9.0"
-pydantic = "^1.8.2"
+pydantic = "^2.4.0"
+pydantic-settings = "^2.1.0"
 python-multipart = "^0.0.5"
 python-jose = {extras = ["cryptography"], version = "^3.3.0"}
 cryptography = "^3.4.7"
 python-dotenv = "^1.0.0"
 pyyaml = "^6.0.1"
 requests = "^2.31.0"
-eth-account = "^0.8.0"
+eth-account = "^0.13.6"
 setuptools = "^69.0.3"
 colorlog = "^6.8.0"
 rich = "^13.7.0"
+httpx = "^0.23.0"
+typer = "^0.4.0"
+web3 = "==7.13.0"
+golem-base-sdk = "==0.1.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.0.0"
@@ -55,7 +60,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.black]
 line-length = 88
-target-version = ['py39']
+target-version = ['py313']
 include = '\.pyi?$'
 
 [tool.isort]