golem-vm-provider 0.1.53__py3-none-any.whl → 0.1.55__py3-none-any.whl

{golem_vm_provider-0.1.53.dist-info → golem_vm_provider-0.1.55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.53
+Version: 0.1.55
 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
@@ -45,7 +45,35 @@ Description-Content-Type: text/markdown
 
 # VM on Golem Provider Node
 
-The Provider Node enables participation in the Golem Network by managing virtual machines and computing resources. It handles VM lifecycle management, resource allocation, network proxying, and automated discovery advertisement.
+Earn by renting out your machine’s compute — like Airbnb for servers. The Provider service runs VMs for requestors, verifies payments via streaming, and lets you withdraw earnings.
+
+## Quick Start (Host and Earn)
+
+1) Install (Python 3.11+ recommended):
+
+```bash
+pip install golem-vm-provider
+```
+
+2) Start the provider (testnet by default is fine):
+
+```bash
+golem-provider start --network testnet
+```
+
+3) Set pricing in USD (GLM rates auto‑compute):
+
+```bash
+golem-provider pricing set --usd-per-core 12 --usd-per-mem 4 --usd-per-disk 0.1
+```
+
+4) On testnets, optionally fund gas for withdrawals:
+
+```bash
+golem-provider wallet faucet-l2
+```
+
+You are now discoverable to requestors and will earn as your VMs run.
 
 ## System Architecture
 
@@ -178,26 +206,26 @@ sequenceDiagram
 -   Clean connection handling
 -   Automatic proxy cleanup
 
-## Installation
+## Installation (from source / development)
 
 1. Prerequisites:
+   - Python 3.11+
+   - Multipass
+   - Poetry (for development)
 
-    - Python 3.9+
-    - Multipass
-    - Poetry
+2. Install from source:
 
-2. Install dependencies:
+```bash
+cd provider-server
+poetry install
+```
 
-    ```bash
-    cd provider-server
-    poetry install
-    ```
+3. Local environment (optional):
 
-3. Configure environment:
-    ```bash
-    cp .env.example .env
-    # Edit .env with your settings
-    ```
+```bash
+cp .env.example .env
+# Edit .env to tweak defaults if needed
+```
 
 ## Configuration
 
@@ -227,9 +255,9 @@ GOLEM_PROVIDER_PORT_RANGE_START={start_port}  # Default: 50800
 GOLEM_PROVIDER_PORT_RANGE_END={end_port}      # Default: 50900
 GOLEM_PROVIDER_PUBLIC_IP="auto"
 
-# Discovery Settings
-GOLEM_PROVIDER_DISCOVERY_URL="http://discovery.golem.network:9001"
-GOLEM_PROVIDER_ADVERTISEMENT_INTERVAL=240
+# Legacy discovery (optional; not required in normal operation)
+# GOLEM_PROVIDER_DISCOVERY_URL="http://discovery.golem.network:9001"
+# GOLEM_PROVIDER_ADVERTISEMENT_INTERVAL=240
 
 # Network Selection
 # Adds an annotation to on-chain advertisements and can be used by requestors to filter
@@ -266,7 +294,7 @@ When enabled, the provider verifies each VM creation request’s `stream_id` and
 - deposit is zero, stream not started, or stream halted
 - (Optional) remaining runway < `STREAM_MIN_REMAINING_SECONDS`
 
-## API Reference
+## API Reference (for integrators)
 
 ### Create VM
 
@@ -372,11 +400,11 @@ Notes:
 ### Starting the Provider
 
 ```bash
-# To run in production mode
-poetry run golem-provider start
+# Production mode
+golem-provider start
 
-# To run in development mode, set the environment and optionally network
-GOLEM_PROVIDER_ENVIRONMENT=development poetry run golem-provider start --network testnet
+# Development mode with extra logs and reload
+GOLEM_PROVIDER_ENVIRONMENT=development golem-provider start --network testnet
 ```
 
 ### Mode vs. Network
@@ -390,6 +418,9 @@ GOLEM_PROVIDER_ENVIRONMENT=development poetry run golem-provider start --network
   - Pair with appropriate RPC envs (`GOLEM_PROVIDER_GOLEM_BASE_RPC_URL`, `GOLEM_PROVIDER_GOLEM_BASE_WS_URL`).
   - Does not change dev ergonomics (logging, reload, or port verification behavior).
 
+- Payments Network (`GOLEM_PROVIDER_PAYMENTS_NETWORK`)
+  - Selects the payments chain profile (e.g., `l2.holesky`, `mainnet`). Determines default payments RPC, faucet enablement, and symbols.
+
 Common setups:
 - Local dev on testnet: `GOLEM_PROVIDER_ENVIRONMENT=development` plus `--network testnet`.
 - Staging on testnet: keep `ENVIRONMENT=production`, set `--network testnet` and testnet RPCs.
@@ -406,17 +437,20 @@ The provider will:
 4. Begin resource advertisement
 5. Listen for VM requests
 
+Notes:
+- Advertisements include both `golem_network` (testnet/mainnet) and `golem_payments_network` (e.g., `l2.holesky`). Requestors default to matching both; they can list all payments networks with a CLI flag.
+
 ### Faucet
 
 - L3 (Golem Base adverts): provider auto-requests funds on startup from `FAUCET_URL` (defaults to EthWarsaw Holesky) protected by CAPTCHA at `CAPTCHA_URL/05381a2cef5e`.
-- L2 (payments): Use the CLI to request native ETH:
+- L2 (payments): Use the CLI to request native ETH (enabled only on testnet profiles):
 
 ```bash
-poetry run golem-provider wallet faucet-l2
+golem-provider wallet faucet-l2
 ```
 
 Defaults:
-- L2 faucet: `https://l2.holesky.golemdb.io/faucet`
+- Faucet URL and enablement come from the active payments profile. On `mainnet` (or other profiles without faucet) the command is disabled.
 - CAPTCHA: `https://cap.gobas.me/05381a2cef5e`
 - Override with env: `GOLEM_PROVIDER_L2_FAUCET_URL`, `GOLEM_PROVIDER_L2_CAPTCHA_URL`, `GOLEM_PROVIDER_L2_CAPTCHA_API_KEY`.
 
@@ -460,10 +494,10 @@ Configure monitor and withdraw via CLI:
 
 ```bash
 # Set monitor to require 1h remaining, check every 30s
-poetry run golem-provider config monitor --enable true --interval 30 --min-remaining 3600
+golem-provider config monitor --enable true --interval 30 --min-remaining 3600
 
 # Enable auto-withdraw every 15 minutes when >= 1e15 wei
-poetry run golem-provider config withdraw --enable true --interval 900 --min-wei 1000000000000000
+golem-provider config withdraw --enable true --interval 900 --min-wei 1000000000000000
 ```
 
 ### Resource Advertisement Flow
@@ -476,6 +510,7 @@ sequenceDiagram
     participant DS as Discovery Service
 
     P->>RT: Initialize
+    P->>RT: Sync with existing VMs
     RT->>AD: Register Callback
     loop Every 4 minutes
         AD->>RT: Get Resources
@@ -485,6 +520,8 @@ sequenceDiagram
     end
 ```
 
+On startup, the provider syncs the resource tracker with all VMs currently running on the host (via Multipass). This ensures advertisements reflect already-allocated CPU, RAM, and storage after restarts, preventing false “outdated advertisement” updates when existing VMs are consuming resources. The sync is based on actual VMs present, independent of any still-open payment streams.
+
 ### Monitoring
 
 The provider includes comprehensive logging:

{golem_vm_provider-0.1.53.dist-info → golem_vm_provider-0.1.55.dist-info}/RECORD

@@ -2,26 +2,26 @@ provider/__init__.py,sha256=HO1fkPpZqPO3z8O8-eVIyx8xXSMIVuTR_b1YF0RtXOg,45
 provider/api/__init__.py,sha256=ssX1ugDqEPt8Fn04IymgmG-Ev8PiXLsCSaiZVvHQnec,344
 provider/api/models.py,sha256=CmfgXqSH3m0HLqY6JvUFI-2IrdGf3EhNKtZ5kbIAX-U,4304
 provider/api/routes.py,sha256=RaOhdUZLJVmCHFWHyhYF9kdBmsFSe5rThIYsW6meMrQ,13194
-provider/config.py,sha256=GsrhbZYvMla1WWSHUg6q4wn0_SK3zgSPtlWGve_H2e8,24932
+provider/config.py,sha256=IDeAYQ4z8oaT5HcG9jFQhSZrLlLU6wMTGDTbSxK6FSc,28901
 provider/container.py,sha256=81x5LiA-qjYN1Uh_JdOxqvuIXiNDr9X3OXNN0VqYFCI,3681
 provider/data/deployments/l2.json,sha256=XTNN2C5LkBfp4YbDKdUKfWMdp1fKnfv8D3TgcwVWxtQ,249
 provider/discovery/__init__.py,sha256=Y6o8RxGevBpuQS3k32y-zSVbP6HBXG3veBl9ElVPKaU,349
 provider/discovery/advertiser.py,sha256=o-LiDl1j0lXMUU0-zPe3qerjpoD2360EA60Y_V_VeBc,6571
-provider/discovery/golem_base_advertiser.py,sha256=fPjBScWDDX5behuQfOFqGTp0tL-sXpLXGbnx3smRmfc,7243
+provider/discovery/golem_base_advertiser.py,sha256=A8bg40b2Ua7PIjx3Y8-SC0s-dUUPWxaiQCzr6AcpYaQ,7334
 provider/discovery/golem_base_utils.py,sha256=xk7vznhMgzrn0AuGyk6-9N9ukp9oPdBbbk1RI-sVjp0,607
 provider/discovery/multi_advertiser.py,sha256=_J79wA1-XQ4GsLzt9KrKpWigGSGBqtut7DaocIk2fyE,991
 provider/discovery/resource_monitor.py,sha256=AmiEc7yBGEGXCunQ-QKmVgosDX3gOhK1Y58LJZXrwAs,949
 provider/discovery/resource_tracker.py,sha256=MP7IXd3aIMsjB4xz5Oj9zFDTEnvrnw-Cyxpl33xcJcc,6006
 provider/discovery/service.py,sha256=vX_mVSxvn3arnb2cKDM_SeJp1ZgPdImP2aUubeXgdRg,915
-provider/main.py,sha256=DJPVjvrTifFIw1l6jk0bwrOt35pmzmdVynv4A1fp9Y0,32137
+provider/main.py,sha256=_j92g56B-d8CE09Ugv0fqWVMi5jw_iuTrysxSw7845A,32309
 provider/network/port_verifier.py,sha256=3l6WNwBHydggJRFYkAsuBp1eCxaU619kjWuM-zSVj2o,13267
 provider/payments/blockchain_service.py,sha256=4GrzDKwCSUVoENqjD4RLyJ0qwBOJKMyVk5Li-XNsyTc,3567
-provider/payments/monitor.py,sha256=Rw17zYsxZre0zU6R0oeRNvVIzMdXLsgoUvSPHpJy6I0,4488
+provider/payments/monitor.py,sha256=seo8vE622IdbcRE3x69IpvHn2mel_tlMNGt_DxOIoww,5386
 provider/payments/stream_map.py,sha256=qk6Y8hS72DplAifZ0ZMWPHBAyc_3IWIQyWUBuCU3_To,1191
 provider/security/ethereum.py,sha256=EwPZj4JR8OEpto6LhKjuuT3Z9pBX6P7-UQaqJtqFkYQ,1242
 provider/security/faucet.py,sha256=8T4lW1fVQgUk8EQILgbrr9UUosw9e7eA40tlZ2_KCPQ,4368
-provider/security/l2_faucet.py,sha256=qp6Q2F44jsX5w8zZ14gzILesiGSxJhC1E_VVgqerBgY,2388
-provider/service.py,sha256=IIjeSM9T4r616nBRnxCUum_sgbyRusMMcja3yQd8zQI,3383
+provider/security/l2_faucet.py,sha256=yRV4xdPBgU8-LDTLqtuAijfgIoe2kYxvXqJLxFd-BVI,2662
+provider/service.py,sha256=hlQn0woppsYFHZDMEgq-40cOjmiPWruiWLy_dQvaCRU,6859
 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
@@ -39,7 +39,7 @@ provider/vm/port_manager.py,sha256=iYSwjTjD_ziOhG8aI7juKHw1OwwRUTJQyQoRUNQvz9w,1
 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=Ki4SGNIZUq3XmaPMwAOoNzdZzKQsmFXid374wgjFPes,4636
-golem_vm_provider-0.1.53.dist-info/METADATA,sha256=mlrOME9VDQLPlCg8odOOc2u_q261s4Ox5C71-SjU8R0,17433
-golem_vm_provider-0.1.53.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-golem_vm_provider-0.1.53.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
-golem_vm_provider-0.1.53.dist-info/RECORD,,
+golem_vm_provider-0.1.55.dist-info/METADATA,sha256=_GZ2hyX-aeTtK--VOiSE4tZfAnQwANw21tO63EvOskY,18877
+golem_vm_provider-0.1.55.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.55.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
+golem_vm_provider-0.1.55.dist-info/RECORD,,

provider/config.py

@@ -57,6 +57,17 @@ class Settings(BaseSettings):
     # Logical network selector for annotation and client defaults
     NETWORK: str = "mainnet"  # one of: "testnet", "mainnet"
 
+    # Payments chain selection (modular network profiles). Keep default on l2.holesky
+    PAYMENTS_NETWORK: str = Field(
+        default="l2.holesky",
+        description="Payments network profile (e.g., 'l2.holesky', 'kaolin.holesky', 'mainnet')"
+    )
+
+    @field_validator("PAYMENTS_NETWORK", mode='before')
+    @classmethod
+    def prefer_payments_network_env(cls, v: str) -> str:
+        return os.environ.get("GOLEM_PROVIDER_PAYMENTS_NETWORK", v)
+
     @property
     def DEV_MODE(self) -> bool:
         return self.ENVIRONMENT == "development"
@@ -138,8 +149,8 @@ class Settings(BaseSettings):
 
     # Polygon / Payments
     POLYGON_RPC_URL: str = Field(
-        default="https://l2.holesky.golemdb.io/rpc",
-        description="EVM RPC URL for streaming payments (L2 by default)"
+        default="",
+        description="EVM RPC URL for streaming payments; defaults from PAYMENTS_NETWORK profile"
     )
     STREAM_PAYMENT_ADDRESS: str = Field(
         default="",
@@ -181,8 +192,8 @@ class Settings(BaseSettings):
 
     # L2 payments faucet (native ETH)
     L2_FAUCET_URL: str = Field(
-        default="https://l2.holesky.golemdb.io/faucet",
-        description="L2 faucet base URL (no trailing /api)"
+        default="",
+        description="Faucet base URL (no trailing /api). Only used on testnets; defaults from PAYMENTS_NETWORK profile"
     )
     L2_CAPTCHA_URL: str = Field(
         default="https://cap.gobas.me",
@@ -193,17 +204,42 @@ class Settings(BaseSettings):
         description="CAPTCHA API key path segment"
     )
 
+    @field_validator("L2_CAPTCHA_URL", mode='before')
+    @classmethod
+    def prefer_l2_captcha_url(cls, v: str) -> str:
+        return os.environ.get("GOLEM_PROVIDER_L2_CAPTCHA_URL", v)
+
+    @field_validator("L2_CAPTCHA_API_KEY", mode='before')
+    @classmethod
+    def prefer_l2_captcha_key(cls, v: str) -> str:
+        return os.environ.get("GOLEM_PROVIDER_L2_CAPTCHA_API_KEY", v)
+
     @field_validator("POLYGON_RPC_URL", mode='before')
     @classmethod
-    def prefer_custom_env(cls, v: str) -> str:
+    def prefer_custom_env(cls, v: str, values: dict) -> str:
         # Accept alternative aliases for payments RPC
         for key in ("GOLEM_PROVIDER_L2_RPC_URL", "GOLEM_PROVIDER_KAOLIN_RPC_URL"):
             if os.environ.get(key):
                 return os.environ[key]
-        return v
+        if v:
+            return v
+        # Default from profile
+        pn = values.data.get("PAYMENTS_NETWORK") or "l2.holesky"
+        return Settings._profile_defaults(pn)["rpc_url"]
+
+    @field_validator("L2_FAUCET_URL", mode='before')
+    @classmethod
+    def prefer_faucet_env(cls, v: str, values: dict) -> str:
+        for key in ("GOLEM_PROVIDER_L2_FAUCET_URL",):
+            if os.environ.get(key):
+                return os.environ[key]
+        if v:
+            return v
+        pn = values.data.get("PAYMENTS_NETWORK") or "l2.holesky"
+        return Settings._profile_defaults(pn).get("faucet_url", "")
 
     @staticmethod
-    def _load_l2_deployment() -> tuple[str | None, str | None]:
+    def _load_deployment(network: str) -> tuple[str | None, str | None]:
         """Try to load default StreamPayment + token from contracts/deployments/l2.json.
 
         Returns (stream_payment_address, glm_token_address) or (None, None) if not found.
@@ -212,15 +248,15 @@ class Settings(BaseSettings):
             # Allow override via env
             base = os.environ.get("GOLEM_DEPLOYMENTS_DIR")
             if base:
-                path = Path(base) / "l2.json"
+                path = Path(base) / f"{Settings._deployment_basename(network)}.json"
             else:
                 # repo root = ../../ from this file
-                path = Path(__file__).resolve().parents[2] / "contracts" / "deployments" / "l2.json"
+                path = Path(__file__).resolve().parents[2] / "contracts" / "deployments" / f"{Settings._deployment_basename(network)}.json"
             if not path.exists():
                 # Try package resource fallback
                 try:
                     import importlib.resources as ir
-                    with ir.files("provider.data.deployments").joinpath("l2.json").open("r") as fh:  # type: ignore[attr-defined]
+                    with ir.files("provider.data.deployments").joinpath(f"{Settings._deployment_basename(network)}.json").open("r") as fh:  # type: ignore[attr-defined]
                         data = json.load(fh)
                 except Exception:
                     return None, None
@@ -235,29 +271,90 @@ class Settings(BaseSettings):
             pass
         return None, None
 
+    # Backwards-compat helper used by tests expecting this method name
+    @staticmethod
+    def _load_l2_deployment() -> tuple[str | None, str | None]:
+        return Settings._load_deployment("l2.holesky")
+
+    @staticmethod
+    def _deployment_basename(network: str) -> str:
+        n = (network or "").lower()
+        if n in ("l2", "l2.holesky"):
+            return "l2"
+        if "." in n:
+            return n.split(".")[0]
+        return n or "l2"
+
+    @staticmethod
+    def _profile_defaults(network: str) -> dict[str, str | bool]:
+        n = (network or "l2.holesky").lower()
+        profiles = {
+            "l2.holesky": {
+                "rpc_url": "https://l2.holesky.golemdb.io/rpc",
+                "faucet_url": "https://l2.holesky.golemdb.io/faucet",
+                "faucet_enabled": True,
+                "token_symbol": "GLM",
+                "gas_symbol": "ETH",
+            },
+            "mainnet": {
+                "rpc_url": "",
+                "faucet_url": "",
+                "faucet_enabled": False,
+                "token_symbol": "GLM",
+                "gas_symbol": "ETH",
+            },
+        }
+        return profiles.get(n, profiles["l2.holesky"])  # default to current standard
+
     @field_validator("STREAM_PAYMENT_ADDRESS", mode='before')
     @classmethod
-    def default_stream_addr(cls, v: str) -> str:
+    def default_stream_addr(cls, v: str, values: dict) -> str:
         # Disable payments during pytest to keep unit tests independent
         if os.environ.get("PYTEST_CURRENT_TEST"):
             return "0x0000000000000000000000000000000000000000"
         if v:
             return v
-        addr, _ = Settings._load_l2_deployment()
+        pn = values.data.get("PAYMENTS_NETWORK") or "l2.holesky"
+        addr, _ = Settings._load_deployment(pn)
         return addr or "0x0000000000000000000000000000000000000000"
 
     @field_validator("GLM_TOKEN_ADDRESS", mode='before')
     @classmethod
-    def default_token_addr(cls, v: str) -> str:
+    def default_token_addr(cls, v: str, values: dict) -> str:
         if os.environ.get("PYTEST_CURRENT_TEST"):
             return "0x0000000000000000000000000000000000000000"
         if v:
             return v
-        _, token = Settings._load_l2_deployment()
+        pn = values.data.get("PAYMENTS_NETWORK") or "l2.holesky"
+        _, token = Settings._load_deployment(pn)
         return token or "0x0000000000000000000000000000000000000000"
 
     # VM Settings
     MAX_VMS: int = 10
+
+    # Optional human-friendly symbols from profile
+    TOKEN_SYMBOL: str = Field(default="", description="Payment token symbol, e.g., GLM")
+    GAS_TOKEN_SYMBOL: str = Field(default="", description="Gas token symbol, e.g., ETH")
+
+    @field_validator("TOKEN_SYMBOL", mode='before')
+    @classmethod
+    def default_token_symbol(cls, v: str, values: dict) -> str:
+        if v:
+            return v
+        pn = values.data.get("PAYMENTS_NETWORK") or "l2.holesky"
+        return str(Settings._profile_defaults(pn).get("token_symbol", ""))
+
+    @field_validator("GAS_TOKEN_SYMBOL", mode='before')
+    @classmethod
+    def default_gas_symbol(cls, v: str, values: dict) -> str:
+        if v:
+            return v
+        pn = values.data.get("PAYMENTS_NETWORK") or "l2.holesky"
+        return str(Settings._profile_defaults(pn).get("gas_symbol", ""))
+
+    @property
+    def FAUCET_ENABLED(self) -> bool:
+        return bool(self._profile_defaults(self.PAYMENTS_NETWORK).get("faucet_enabled", False))
     DEFAULT_VM_IMAGE: str = "ubuntu:24.04"
     VM_DATA_DIR: str = ""
     SSH_KEY_DIR: str = ""

provider/discovery/golem_base_advertiser.py

@@ -68,6 +68,7 @@ class GolemBaseAdvertiser(Advertiser):
             string_annotations = [
                 Annotation(key="golem_type", value="provider"),
                 Annotation(key="golem_network", value=settings.NETWORK),
+                Annotation(key="golem_payments_network", value=settings.PAYMENTS_NETWORK),
                 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),

provider/main.py

@@ -149,6 +149,9 @@ def wallet_faucet_l2():
     from .config import settings
     from .security.l2_faucet import L2FaucetService
     try:
+        if not bool(getattr(settings, "FAUCET_ENABLED", False)):
+            print("Faucet is disabled for current payments network.")
+            raise typer.Exit(code=0)
         addr = settings.PROVIDER_ID
         async def _run():
             svc = L2FaucetService(settings)

provider/payments/monitor.py

@@ -56,21 +56,41 @@ class StreamMonitor:
                         logger.warning(f"stream {stream_id} lookup failed: {e}")
                         continue
                     # Stop VM if remaining runway < threshold
-                    remaining = max(s["stopTime"] - now, 0)
+                    remaining = max(int(s["stopTime"]) - int(now), 0)
                     logger.debug(
                         f"stream {stream_id} for VM {vm_id}: start={s['startTime']} stop={s['stopTime']} "
                         f"rate={s['ratePerSecond']} withdrawn={s['withdrawn']} halted={s['halted']} remaining={remaining}s"
                     )
-                    if self._get("STREAM_MONITOR_ENABLED", False) and remaining < int(self._get("STREAM_MIN_REMAINING_SECONDS", 0)):
-                        logger.info(f"Stopping VM {vm_id} due to low stream runway ({remaining}s)")
+                    # If stream is force-halted, delete immediately to free all resources
+                    if bool(s.get("halted")):
+                        logger.info(
+                            f"Deleting VM {vm_id} due to halted stream (id={stream_id}, now={now})"
+                        )
+                        try:
+                            await self.vm_service.delete_vm(vm_id)
+                        except Exception as e:
+                            logger.warning(f"delete_vm failed for {vm_id}: {e}")
+                        try:
+                            await self.stream_map.remove(vm_id)
+                        except Exception as e:
+                            logger.debug(f"failed to remove vm {vm_id} from stream map: {e}")
+                        continue
+
+                    # Only stop a VM when runway is completely empty
+                    if remaining == 0:
+                        logger.info(
+                            f"Stopping VM {vm_id} as stream runway is exhausted (id={stream_id}, now={now}, stop={s.get('stopTime')})"
+                        )
                         try:
                             await self.vm_service.stop_vm(vm_id)
                         except Exception as e:
                             logger.warning(f"stop_vm failed for {vm_id}: {e}")
-                    else:
-                        logger.debug(
-                            f"VM {vm_id} stream {stream_id} healthy (remaining={remaining}s, threshold={self._get('STREAM_MIN_REMAINING_SECONDS', 0)}s)"
-                        )
+                        continue
+
+                    # Otherwise, do not stop; just log health and consider withdrawals
+                    logger.debug(
+                        f"VM {vm_id} stream {stream_id} healthy (remaining={remaining}s)"
+                    )
                     # Withdraw if enough vested and configured
                     if self._get("STREAM_WITHDRAW_ENABLED", False) and self.client:
                         vested = max(min(now, s["stopTime"]) - s["startTime"], 0) * s["ratePerSecond"]

provider/security/l2_faucet.py

@@ -38,6 +38,10 @@ class L2FaucetService:
 
         Returns tx hash string on payout, or None if skipped/failed.
         """
+        # Respect profile gating only if explicitly present and false
+        if hasattr(self.cfg, "FAUCET_ENABLED") and not bool(getattr(self.cfg, "FAUCET_ENABLED")):
+            logger.info("Faucet disabled for current payments network; skipping.")
+            return None
         bal = self._balance_eth(address)
         if bal > 0.01:
             logger.info(f"Sufficient L2 funds ({bal} ETH), skipping faucet.")
@@ -60,4 +64,3 @@ class L2FaucetService:
         if tx:
             logger.success(f"L2 faucet sent tx: {tx}")
         return tx
-

provider/service.py

@@ -37,6 +37,68 @@ class ProviderService:
             # Initialize services
             await self.port_manager.initialize()
             await self.vm_service.provider.initialize()
+
+            # Before starting advertisement, sync allocated resources with existing VMs
+            try:
+                vm_resources = await self.vm_service.get_all_vms_resources()
+                await self.vm_service.resource_tracker.sync_with_multipass(vm_resources)
+            except Exception as e:
+                logger.warning(f"Failed to sync resources with existing VMs: {e}")
+
+            # Cross-check running VMs against payment streams. If a VM has no
+            # active stream, it is no longer rented: terminate it and free resources.
+            try:
+                # Only perform checks if payments are configured
+                if settings.STREAM_PAYMENT_ADDRESS and not settings.STREAM_PAYMENT_ADDRESS.lower().endswith("0000000000000000000000000000000000000000") and settings.POLYGON_RPC_URL:
+                    stream_map = app.container.stream_map()
+                    reader = app.container.stream_reader()
+
+                    # Use the most recent view of VMs from the previous sync
+                    vm_ids = list(vm_resources.keys()) if 'vm_resources' in locals() else []
+                    for vm_id in vm_ids:
+                        try:
+                            stream_id = await stream_map.get(vm_id)
+                        except Exception:
+                            stream_id = None
+
+                        if stream_id is None:
+                            reason = "no stream mapped"
+                            should_terminate = True
+                        else:
+                            try:
+                                ok, msg = reader.verify_stream(int(stream_id), settings.PROVIDER_ID)
+                                should_terminate = not ok
+                                reason = msg if not ok else "ok"
+                            except Exception as e:
+                                # If verification cannot be performed, be conservative and keep the VM
+                                logger.warning(f"Stream verification error for VM {vm_id} (stream {stream_id}): {e}")
+                                should_terminate = False
+                                reason = f"verification error: {e}"
+
+                        if should_terminate:
+                            logger.info(
+                                f"Deleting VM {vm_id}: inactive stream (stream_id={stream_id}, reason={reason})"
+                            )
+                            try:
+                                await self.vm_service.delete_vm(vm_id)
+                            except Exception as e:
+                                logger.warning(f"Failed to delete VM {vm_id}: {e}")
+                            try:
+                                await stream_map.remove(vm_id)
+                            except Exception:
+                                pass
+
+                    # Re-sync after any terminations to ensure ads reflect capacity
+                    try:
+                        vm_resources = await self.vm_service.get_all_vms_resources()
+                        await self.vm_service.resource_tracker.sync_with_multipass(vm_resources)
+                    except Exception as e:
+                        logger.warning(f"Post-termination resource sync failed: {e}")
+                else:
+                    logger.info("Payments not configured; skipping startup stream checks")
+            except Exception as e:
+                logger.warning(f"Failed to reconcile VMs with payment streams: {e}")
+
             await self.advertisement_service.start()
             # Start pricing auto-updater; trigger re-advertise after updates
             async def _on_price_updated(platform: str, glm_usd):