golem-vm-provider 0.1.52__py3-none-any.whl → 0.1.54__py3-none-any.whl

{golem_vm_provider-0.1.52.dist-info → golem_vm_provider-0.1.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.52
+Version: 0.1.54
 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`.
 
@@ -454,14 +488,16 @@ poetry run golem-provider streams withdraw --vm-id <vm_id>
 poetry run golem-provider streams withdraw --all
 ```
 
+Note: On testnets, the withdraw command auto-attempts to fund the provider's L2 address via the configured faucet if native gas balance is low.
+
 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

{golem_vm_provider-0.1.52.dist-info → golem_vm_provider-0.1.54.dist-info}/RECORD

@@ -2,24 +2,25 @@ 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=-dkQEwMrU2g1ljGrdf2B6P6CcgpDAjeCEqbBy_E4ybk,32799
+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/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=yRV4xdPBgU8-LDTLqtuAijfgIoe2kYxvXqJLxFd-BVI,2662
 provider/service.py,sha256=IIjeSM9T4r616nBRnxCUum_sgbyRusMMcja3yQd8zQI,3383
 provider/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 provider/utils/ascii_art.py,sha256=ykBFsztk57GIiz1NJ-EII5UvN74iECqQL4h9VmiW6Z8,3161
@@ -38,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.52.dist-info/METADATA,sha256=-9IAEK4SfcsssCSwvniqN0hBaIvw3V8yxpEi9plknLw,17288
-golem_vm_provider-0.1.52.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-golem_vm_provider-0.1.52.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
-golem_vm_provider-0.1.52.dist-info/RECORD,,
+golem_vm_provider-0.1.54.dist-info/METADATA,sha256=u7WDC-uHV2F5NJ1ayjL7Vlz2s1yXDRFrOIolk_7V1EM,18452
+golem_vm_provider-0.1.54.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.54.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
+golem_vm_provider-0.1.54.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

@@ -147,38 +147,20 @@ def main():
 def wallet_faucet_l2():
     """Request L2 faucet funds for the provider's payment address (native ETH)."""
     from .config import settings
-    from golem_faucet import PowFaucetClient
-    from web3 import Web3
+    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
-        faucet = PowFaucetClient(settings.L2_FAUCET_URL, settings.L2_CAPTCHA_URL, settings.L2_CAPTCHA_API_KEY)
-        # Check current L2 balance
-        w3 = Web3(Web3.HTTPProvider(settings.POLYGON_RPC_URL))
-        bal = 0.0
-        try:
-            bal = float(w3.from_wei(w3.eth.get_balance(Web3.to_checksum_address(addr)), 'ether'))
-        except Exception:
-            pass
-        if bal > 0.01:
-            print(f"Sufficient L2 funds ({bal} ETH); skipping faucet.")
-            return
         async def _run():
-            chall = await faucet.get_challenge()
-            if not chall:
-                print("Failed to get challenge")
-                raise typer.Exit(code=1)
-            sols = []
-            for salt, target in chall.get('challenge') or []:
-                sols.append((salt, target, PowFaucetClient.solve_challenge(salt, target)))
-            redeemed = await faucet.redeem(chall.get('token'), sols)
-            if not redeemed:
-                print("Failed to redeem solutions")
-                raise typer.Exit(code=1)
-            tx = await faucet.request_funds(addr, redeemed)
+            svc = L2FaucetService(settings)
+            tx = await svc.request_funds(addr)
             if tx:
                 print(f"Faucet tx: {tx}")
             else:
-                print("Faucet request failed")
+                # Either skipped due to sufficient balance or failed
+                pass
         asyncio.run(_run())
     except Exception as e:
         print(f"Error: {e}")
@@ -497,6 +479,7 @@ def streams_withdraw(
     """Withdraw vested funds for one or all streams."""
     from .container import Container
     from .config import settings
+    from .security.l2_faucet import L2FaucetService
     try:
         if not vm_id and not all_streams:
             print("Specify --vm-id or --all")
@@ -505,6 +488,12 @@ def streams_withdraw(
         c.config.from_pydantic(settings)
         stream_map = c.stream_map()
         client = c.stream_client()
+        # Ensure we have L2 gas for withdrawals (testnets)
+        try:
+            asyncio.run(L2FaucetService(settings).request_funds(settings.PROVIDER_ID))
+        except Exception:
+            # Non-fatal; proceed with withdraw attempt
+            pass
         targets = []
         if all_streams:
             items = asyncio.run(stream_map.all_items())

provider/security/l2_faucet.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Optional, List, Tuple
+
+from web3 import Web3
+from golem_faucet import PowFaucetClient
+from ..utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class L2FaucetService:
+    """Request native ETH on the L2 payments chain via PoW faucet.
+
+    Uses provider settings for RPC and faucet endpoints.
+    """
+
+    def __init__(self, config):
+        # Config is expected to expose POLYGON_RPC_URL, L2_* faucet fields
+        self.cfg = config
+        self.web3 = Web3(Web3.HTTPProvider(config.POLYGON_RPC_URL))
+        self.client = PowFaucetClient(
+            faucet_url=getattr(config, "L2_FAUCET_URL", "https://l2.holesky.golemdb.io/faucet"),
+            captcha_base_url=getattr(config, "L2_CAPTCHA_URL", "https://cap.gobas.me"),
+            captcha_api_key=getattr(config, "L2_CAPTCHA_API_KEY", "05381a2cef5e"),
+        )
+
+    def _balance_eth(self, address: str) -> float:
+        try:
+            wei = self.web3.eth.get_balance(Web3.to_checksum_address(address))
+            return float(self.web3.from_wei(wei, "ether"))
+        except Exception as e:
+            logger.warning(f"L2 balance check failed: {e}")
+            return 0.0
+
+    async def request_funds(self, address: str) -> Optional[str]:
+        """Ensure some native ETH on L2; if low, solve PoW and request faucet payout.
+
+        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.")
+            return None
+        chall = await self.client.get_challenge()
+        if not chall:
+            logger.error("could not fetch faucet challenge")
+            return None
+        token = chall.get("token")
+        challenge_list = chall.get("challenge") or []
+        solutions: List[Tuple[str, str, int]] = []
+        for salt, target in challenge_list:
+            nonce = PowFaucetClient.solve_challenge(salt, target)
+            solutions.append((salt, target, nonce))
+        redeemed = await self.client.redeem(token, solutions)
+        if not redeemed:
+            logger.error("failed to redeem challenge")
+            return None
+        tx = await self.client.request_funds(address, redeemed)
+        if tx:
+            logger.success(f"L2 faucet sent tx: {tx}")
+        return tx