golem-vm-provider 0.1.39__py3-none-any.whl → 0.1.42__py3-none-any.whl

{golem_vm_provider-0.1.39.dist-info → golem_vm_provider-0.1.42.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.39
+Version: 0.1.42
 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
@@ -23,6 +23,8 @@ Requires-Dist: dependency-injector (>=4.41.0,<5.0.0)
 Requires-Dist: eth-account (>=0.13.6,<0.14.0)
 Requires-Dist: fastapi (>=0.103.0,<0.104.0)
 Requires-Dist: golem-base-sdk (==0.1.0)
+Requires-Dist: golem-faucet (>=0.1.0,<0.2.0)
+Requires-Dist: golem-streaming-abi (>=0.1.0,<0.2.0)
 Requires-Dist: httpx (>=0.23.0,<0.24.0)
 Requires-Dist: psutil (>=5.9.0,<6.0.0)
 Requires-Dist: pydantic (>=2.4.0,<3.0.0)
@@ -228,15 +230,19 @@ GOLEM_PROVIDER_PUBLIC_IP="auto"
 # Discovery Settings
 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
+GOLEM_PROVIDER_NETWORK="testnet"  # or "mainnet"
 ```
 
-### Streaming Payments (Polygon GLM)
+### Streaming Payments (Native ETH on L2)
 
-Enable on‑chain stream‑gated rentals by configuring the following (env prefix `GOLEM_PROVIDER_`):
+Enable on‑chain stream‑gated rentals funded in native ETH. Configure (env prefix `GOLEM_PROVIDER_`):
 
-- `POLYGON_RPC_URL` — Polygon PoS RPC URL (e.g., https://polygon-rpc.com)
+- `POLYGON_RPC_URL` — EVM RPC URL (default points to L2: https://l2.holesky.golemdb.io/rpc)
 - `STREAM_PAYMENT_ADDRESS` — StreamPayment contract address; if non‑zero, VM creation requires a valid `stream_id`
-- `GLM_TOKEN_ADDRESS` — GLM ERC20 address (for info endpoint)
+- `GLM_TOKEN_ADDRESS` — Token address; set to `0x0000000000000000000000000000000000000000` to indicate native ETH
 
 Optional background automation (all disabled by default):
 
@@ -247,6 +253,12 @@ Optional background automation (all disabled by default):
 - `STREAM_WITHDRAW_INTERVAL_SECONDS` — how often to attempt withdrawals (default 1800)
 - `STREAM_MIN_WITHDRAW_WEI` — only withdraw when >= this amount (gas‑aware)
 
+Implementation notes:
+
+- The provider exposes `GET /api/v1/provider/info` returning `provider_id`, `stream_payment_address`, and `glm_token_address`. For ETH mode this field is the zero address (`0x000...000`). Requestors should prefer these values when opening streams.
+- On successful VM creation with a valid `stream_id`, the provider persists a VM→stream mapping in `streams.json`. This enables the background monitor to stop VMs with low remaining runway and to withdraw vested funds according to configured intervals.
+- When a VM is deleted, the VM→stream mapping is cleaned up.
+
 When enabled, the provider verifies each VM creation request’s `stream_id` and refuses to start the VM if:
 
 - stream recipient != provider’s Ethereum address
@@ -310,7 +322,8 @@ Response:
 {
   "provider_id": "0xProviderEthereumAddress",
   "stream_payment_address": "0xStreamPayment",
-  "glm_token_address": "0xGLM"
+  "glm_token_address": "0x0000000000000000000000000000000000000000"  
+  
 }
 ```
 
@@ -324,10 +337,26 @@ Use this endpoint to discover the correct recipient for creating a GLM stream.
 # To run in production mode
 poetry run golem-provider start
 
-# To run in development mode
-poetry run golem-provider dev
+# To run in development mode, set the environment and optionally network
+GOLEM_PROVIDER_ENVIRONMENT=development poetry run golem-provider start --network testnet
 ```
 
+### Mode vs. Network
+
+- Development Mode (`GOLEM_PROVIDER_ENVIRONMENT=development`)
+  - Optimizes for local iteration: enables reload + debug logging and uses local defaults (e.g., local port check servers). May derive a local/LAN IP automatically and prefix the provider name with `DEVMODE-`.
+  - Does not decide which chain you target.
+
+- Network Selection (`--network` or `GOLEM_PROVIDER_NETWORK`)
+  - Chooses the discovery/advertisement scope: providers advertise `golem_network=testnet|mainnet` and requestors filter accordingly.
+  - 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).
+
+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.
+- Production on mainnet: `ENVIRONMENT=production` with `--network mainnet` and mainnet RPCs.
+
 The provider will:
 
 1. Verify port accessibility
@@ -339,6 +368,20 @@ The provider will:
 4. Begin resource advertisement
 5. Listen for VM requests
 
+### 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:
+
+```bash
+poetry run golem-provider wallet faucet-l2
+```
+
+Defaults:
+- L2 faucet: `https://l2.holesky.golemdb.io/faucet`
+- 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`.
+
 ### Resource Advertisement Flow
 
 ```mermaid

{golem_vm_provider-0.1.39.dist-info → golem_vm_provider-0.1.42.dist-info}/RECORD

@@ -1,24 +1,24 @@
 provider/__init__.py,sha256=HO1fkPpZqPO3z8O8-eVIyx8xXSMIVuTR_b1YF0RtXOg,45
 provider/api/__init__.py,sha256=ssX1ugDqEPt8Fn04IymgmG-Ev8PiXLsCSaiZVvHQnec,344
 provider/api/models.py,sha256=_y3N9amTFaHfH7_3uZlvhPAoUA4HY-93f-BBuC4EoBM,3830
-provider/api/routes.py,sha256=YCAJT9Cw4H5phbgsbYwppcn8H_3G1ogom6mdaPM-tHs,7683
-provider/config.py,sha256=98gBZiBdzzF5AuPvEiv4N79mgf0G2zZeld2_kMJ-DKA,21673
+provider/api/routes.py,sha256=DODju_SOgfkyeZv9zLTuAXbyvdaWRbU4kHZpON_GeMg,8288
+provider/config.py,sha256=u7Y0w9-s8iitQzQ3R0ztgYSfq_WeSRUYzBRTor8GAlY,22666
 provider/container.py,sha256=81x5LiA-qjYN1Uh_JdOxqvuIXiNDr9X3OXNN0VqYFCI,3681
 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=_UgxsedmBvSRX919wCp4Wo-pZV5fncesXj1k2h3jkXY,6869
+provider/discovery/golem_base_advertiser.py,sha256=0I6V73GL671c8mQNpb92sdyboXzbJuRJdv06QS7MuBQ,6942
 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=V1n7IFhV0Y2WMjD1_IomEYptdRu1G-K6U0JL8ip8Th8,11962
+provider/main.py,sha256=eS_rqvC9bCXdJfYg-sNYt02SGPdodgPGa350SWcd1os,14271
 provider/network/port_verifier.py,sha256=3l6WNwBHydggJRFYkAsuBp1eCxaU619kjWuM-zSVj2o,13267
-provider/payments/blockchain_service.py,sha256=0iHfvviQMSFfRSSqK0Y4gdbqPa0mrxtJIN4nSG9D0D0,5171
-provider/payments/monitor.py,sha256=kEuD_-amaNJY6Hkrx5hvWPqNtaslnruq3_EynB4bdUY,2804
+provider/payments/blockchain_service.py,sha256=Qq01M7N_gzUidnXBngDcNoBRs_sHKaTpvSFKz6wEAMk,3363
+provider/payments/monitor.py,sha256=6zzW275ktSHcYiIXuyThr-UA-JR7VoHw2Hk1qAUCb-U,3058
 provider/payments/stream_map.py,sha256=qk6Y8hS72DplAifZ0ZMWPHBAyc_3IWIQyWUBuCU3_To,1191
 provider/security/ethereum.py,sha256=EwPZj4JR8OEpto6LhKjuuT3Z9pBX6P7-UQaqJtqFkYQ,1242
-provider/security/faucet.py,sha256=O2DgP3bIrRUm9tdLCdgnda9em0rPyeW42sWhO1EQJaA,5363
+provider/security/faucet.py,sha256=8T4lW1fVQgUk8EQILgbrr9UUosw9e7eA40tlZ2_KCPQ,4368
 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
@@ -37,7 +37,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.39.dist-info/METADATA,sha256=GiVapYP4oE2as0468l_t3Fp12Y_s_mOR1a9UlDsrETY,12580
-golem_vm_provider-0.1.39.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-golem_vm_provider-0.1.39.dist-info/entry_points.txt,sha256=iFUajRxfViYkFcPMPv2EIjYm-BLOp86LJj_IjCwwZUw,74
-golem_vm_provider-0.1.39.dist-info/RECORD,,
+golem_vm_provider-0.1.42.dist-info/METADATA,sha256=YLJ8-2jYNdZH04C59FRgBTFamsaYmgddmXVctxKHoqY,15197
+golem_vm_provider-0.1.42.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.42.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
+golem_vm_provider-0.1.42.dist-info/RECORD,,

{golem_vm_provider-0.1.39.dist-info → golem_vm_provider-0.1.42.dist-info}/entry_points.txt

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

provider/api/routes.py

@@ -26,6 +26,7 @@ async def create_vm(
     request: CreateVMRequest,
     vm_service: VMService = Depends(Provide[Container.vm_service]),
     settings: Settings = Depends(Provide[Container.config]),
+    stream_map = Depends(Provide[Container.stream_map]),
 ) -> VMInfo:
     """Create a new VM."""
     try:
@@ -51,6 +52,12 @@ async def create_vm(
         )
         
         vm_info = await vm_service.create_vm(config)
+        # Persist VM->stream mapping if provided
+        if request.stream_id is not None:
+            try:
+                await stream_map.set(vm_info.id, int(request.stream_id))
+            except Exception as e:
+                logger.warning(f"failed to persist stream mapping for {vm_info.id}: {e}")
         await vm_creation_animation(request.name)
         return vm_info
     except MultipassError as e:
@@ -164,12 +171,17 @@ async def stop_vm(
 async def delete_vm(
     requestor_name: str,
     vm_service: VMService = Depends(Provide[Container.vm_service]),
+    stream_map = Depends(Provide[Container.stream_map]),
 ) -> None:
     """Delete a VM."""
     try:
         logger.process(f"🗑️  Deleting VM '{requestor_name}'")
         vm_status_change(requestor_name, "STOPPING", "Cleanup in progress")
         await vm_service.delete_vm(requestor_name)
+        try:
+            await stream_map.remove(requestor_name)
+        except Exception as e:
+            logger.warning(f"failed to remove stream mapping for {requestor_name}: {e}")
         vm_status_change(requestor_name, "TERMINATED", "Cleanup complete")
         logger.success(f"✨ Successfully deleted VM '{requestor_name}'")
     except VMNotFoundError as e:

provider/config.py

@@ -6,6 +6,7 @@ import socket
 
 from pydantic_settings import BaseSettings
 from pydantic import field_validator, Field
+import os
 from .utils.logging import setup_logger
 
 logger = setup_logger(__name__)
@@ -52,6 +53,8 @@ class Settings(BaseSettings):
     PORT: int = 7466
     SKIP_PORT_VERIFICATION: bool = False
     ENVIRONMENT: str = "production"
+    # Logical network selector for annotation and client defaults
+    NETWORK: str = "mainnet"  # one of: "testnet", "mainnet"
 
     @property
     def DEV_MODE(self) -> bool:
@@ -68,9 +71,6 @@ class Settings(BaseSettings):
     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"
  
     @field_validator("ETHEREUM_KEY_DIR", mode='before')
     def resolve_key_dir(cls, v: str) -> str:
@@ -137,8 +137,8 @@ class Settings(BaseSettings):
 
     # Polygon / Payments
     POLYGON_RPC_URL: str = Field(
-        default="https://polygon-rpc.com",
-        description="Polygon PoS RPC URL for GLM payments"
+        default="https://l2.holesky.golemdb.io/rpc",
+        description="EVM RPC URL for streaming payments (L2 by default)"
     )
     STREAM_PAYMENT_ADDRESS: str = Field(
         default="0x0000000000000000000000000000000000000000",
@@ -146,7 +146,7 @@ class Settings(BaseSettings):
     )
     GLM_TOKEN_ADDRESS: str = Field(
         default="0x0000000000000000000000000000000000000000",
-        description="GLM ERC20 token address on target network"
+        description="Token address (0x0 means native ETH)"
     )
     STREAM_MIN_REMAINING_SECONDS: int = Field(
         default=3600,
@@ -173,6 +173,34 @@ class Settings(BaseSettings):
         description="Min withdrawable amount (wei) before triggering withdraw"
     )
 
+    # Faucet settings (L3 for Golem Base adverts)
+    FAUCET_URL: str = "https://ethwarsaw.holesky.golemdb.io/faucet"
+    CAPTCHA_URL: str = "https://cap.gobas.me"
+    CAPTCHA_API_KEY: str = "05381a2cef5e"
+
+    # 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)"
+    )
+    L2_CAPTCHA_URL: str = Field(
+        default="https://cap.gobas.me",
+        description="CAPTCHA base URL"
+    )
+    L2_CAPTCHA_API_KEY: str = Field(
+        default="05381a2cef5e",
+        description="CAPTCHA API key path segment"
+    )
+
+    @field_validator("POLYGON_RPC_URL", mode='before')
+    @classmethod
+    def prefer_custom_env(cls, v: str) -> 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
+
     # VM Settings
     MAX_VMS: int = 10
     DEFAULT_VM_IMAGE: str = "ubuntu:24.04"

provider/discovery/golem_base_advertiser.py

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

@@ -122,7 +122,9 @@ except ImportError:
 
 cli = typer.Typer()
 pricing_app = typer.Typer(help="Configure USD pricing; auto-converts to GLM.")
+wallet_app = typer.Typer(help="Wallet utilities (funding, balance)")
 cli.add_typer(pricing_app, name="pricing")
+cli.add_typer(wallet_app, name="wallet")
 
 def print_version(ctx: typer.Context, value: bool):
     if not value:
@@ -141,15 +143,57 @@ def main(
     ensure_config()
     pass
 
+
+@wallet_app.command("faucet-l2")
+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
+    try:
+        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)
+            if tx:
+                print(f"Faucet tx: {tx}")
+            else:
+                print("Faucet request failed")
+        asyncio.run(_run())
+    except Exception as e:
+        print(f"Error: {e}")
+        raise typer.Exit(code=1)
+
 @cli.command()
-def start(no_verify_port: bool = typer.Option(False, "--no-verify-port", help="Skip provider port verification.")):
+def start(
+    no_verify_port: bool = typer.Option(False, "--no-verify-port", help="Skip provider port verification."),
+    network: str = typer.Option(None, "--network", help="Target network: 'testnet' or 'mainnet' (overrides env)")
+):
     """Start the provider server."""
-    run_server(dev_mode=False, no_verify_port=no_verify_port)
+    run_server(dev_mode=False, no_verify_port=no_verify_port, network=network)
 
-@cli.command()
-def dev(no_verify_port: bool = typer.Option(True, "--no-verify-port", help="Skip provider port verification.")):
-    """Start the provider server in development mode."""
-    run_server(dev_mode=True, no_verify_port=no_verify_port)
+# Removed separate 'dev' command; use environment GOLEM_PROVIDER_ENVIRONMENT=development instead.
 
 def _env_path_for(dev_mode: Optional[bool]) -> str:
     from pathlib import Path
@@ -209,22 +253,35 @@ def _print_pricing_examples(glm_usd):
             f"- {name} ({res.cpu}C, {res.memory}GB RAM, {res.storage}GB Disk): ~{usd_str} per month (~{glm_str})"
         )
 
-def run_server(dev_mode: bool, no_verify_port: bool):
+def run_server(dev_mode: bool | None = None, no_verify_port: bool = False, network: str | None = None):
     """Helper to run the uvicorn server."""
     import sys
     from pathlib import Path
     from dotenv import load_dotenv
     import uvicorn
-    # Load appropriate .env file
+    # Decide dev mode from explicit arg or environment
+    if dev_mode is None:
+        dev_mode = os.environ.get("GOLEM_PROVIDER_ENVIRONMENT", "").lower() == "development"
+
+    # Load appropriate .env file based on mode
     env_file = ".env.dev" if dev_mode else ".env"
     env_path = Path(__file__).parent.parent / env_file
     load_dotenv(dotenv_path=env_path)
+
+    # Apply network override early (affects settings and annotations)
+    if network:
+        os.environ["GOLEM_PROVIDER_NETWORK"] = network
     
     # The logic for setting the public IP in dev mode is now handled in config.py
     # The following lines are no longer needed and have been removed.
 
     # Import settings after loading env
     from .config import settings
+    if network:
+        try:
+            settings.NETWORK = network
+        except Exception:
+            pass
 
     # Configure logging with debug mode
     logger = setup_logger(__name__, debug=dev_mode)
@@ -235,6 +292,8 @@ def run_server(dev_mode: bool, no_verify_port: bool):
         for key, value in os.environ.items():
             if key.startswith('GOLEM_PROVIDER_'):
                 logger.info(f"{key}={value}")
+        if network:
+            logger.info(f"Overridden network: {network}")
 
         # Check requirements
         if not check_requirements():
@@ -257,7 +316,7 @@ def run_server(dev_mode: bool, no_verify_port: bool):
             "provider:app",
             host=settings.HOST,
             port=settings.PORT,
-            reload=settings.DEBUG,
+            reload=dev_mode,
             log_level="debug" if dev_mode else "info",
             log_config=log_config,
             timeout_keep_alive=60,  # Increase keep-alive timeout

provider/payments/blockchain_service.py

@@ -5,53 +5,10 @@ from typing import Any, Dict
 
 from web3 import Web3
 from eth_account import Account
+from golem_streaming_abi import STREAM_PAYMENT_ABI
 
 
-STREAM_PAYMENT_ABI = [
-    {
-        "inputs": [
-            {"internalType": "address", "name": "token", "type": "address"},
-            {"internalType": "address", "name": "recipient", "type": "address"},
-            {"internalType": "uint256", "name": "deposit", "type": "uint256"},
-            {"internalType": "uint128", "name": "ratePerSecond", "type": "uint128"},
-        ],
-        "name": "createStream",
-        "outputs": [{"internalType": "uint256", "name": "streamId", "type": "uint256"}],
-        "stateMutability": "nonpayable",
-        "type": "function",
-    },
-    {
-        "inputs": [{"internalType": "uint256", "name": "streamId", "type": "uint256"}],
-        "name": "withdraw",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function",
-    },
-    {
-        "inputs": [{"internalType": "uint256", "name": "streamId", "type": "uint256"}],
-        "name": "terminate",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function",
-    },
-    {
-        "inputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
-        "name": "streams",
-        "outputs": [
-            {"internalType": "address", "name": "token", "type": "address"},
-            {"internalType": "address", "name": "sender", "type": "address"},
-            {"internalType": "address", "name": "recipient", "type": "address"},
-            {"internalType": "uint128", "name": "startTime", "type": "uint128"},
-            {"internalType": "uint128", "name": "stopTime", "type": "uint128"},
-            {"internalType": "uint128", "name": "ratePerSecond", "type": "uint128"},
-            {"internalType": "uint256", "name": "deposit", "type": "uint256"},
-            {"internalType": "uint256", "name": "withdrawn", "type": "uint256"},
-            {"internalType": "bool", "name": "halted", "type": "bool"}
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-]
+ # ABI imported from shared package
 
 
 @dataclass
@@ -89,6 +46,10 @@ class StreamPaymentClient:
         fn = self.contract.functions.withdraw(int(stream_id))
         receipt = self._send(fn)
         return receipt["transactionHash"]
+    def terminate(self, stream_id: int) -> str:
+        fn = self.contract.functions.terminate(int(stream_id))
+        receipt = self._send(fn)
+        return receipt["transactionHash"]
 
 class StreamPaymentReader:
     def __init__(self, rpc_url: str, contract_address: str):
@@ -129,7 +90,4 @@ class StreamPaymentReader:
             return False, "stream halted"
         return True, "ok"
 
-    def terminate(self, stream_id: int) -> str:
-        fn = self.contract.functions.terminate(int(stream_id))
-        receipt = self._send(fn)
-        return receipt["transactionHash"]
+    # Reader should remain read-only; no terminate here

provider/payments/monitor.py

@@ -52,13 +52,16 @@ class StreamMonitor:
                     if self.settings.STREAM_WITHDRAW_ENABLED and self.client:
                         vested = max(min(now, s["stopTime"]) - s["startTime"], 0) * s["ratePerSecond"]
                         withdrawable = max(vested - s["withdrawn"], 0)
-                        if withdrawable >= self.settings.STREAM_MIN_WITHDRAW_WEI:
+                        # Enforce a minimum interval between withdrawals
+                        if withdrawable >= self.settings.STREAM_MIN_WITHDRAW_WEI and (
+                            now - last_withdraw >= self.settings.STREAM_WITHDRAW_INTERVAL_SECONDS
+                        ):
                             try:
                                 self.client.withdraw(stream_id)
+                                last_withdraw = now
                             except Exception as e:
                                 logger.warning(f"withdraw failed for {stream_id}: {e}")
             except asyncio.CancelledError:
                 break
             except Exception as e:
                 logger.error(f"stream monitor error: {e}")
-

provider/security/faucet.py

@@ -1,10 +1,9 @@
 import asyncio
-import hashlib
-import httpx
-from typing import Optional
+from typing import Optional, List, Tuple
 
 from golem_base_sdk import GolemBaseClient
 from provider.utils.logging import setup_logger
+from golem_faucet import PowFaucetClient
 
 logger = setup_logger(__name__)
 
@@ -13,11 +12,12 @@ 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.faucet_url = faucet_url.rstrip("/")
+        self.captcha_url = captcha_url.rstrip("/")
         self.captcha_api_key = captcha_api_key
-        self.api_endpoint = f"{faucet_url}/api"
+        self.api_endpoint = f"{self.faucet_url}/api"
         self.client: Optional[GolemBaseClient] = None
+        self._pow = PowFaucetClient(self.faucet_url, self.captcha_url, self.captcha_api_key)
 
     async def _ensure_client(self):
         if not self.client:
@@ -82,51 +82,27 @@ class FaucetClient:
     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 await self._pow.get_challenge()
+        except Exception as e:
+            logger.error(f"Failed to get PoW challenge: {e}")
             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
+        return PowFaucetClient.solve_challenge(salt, target)
 
     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 await self._pow.redeem(token, solutions)
+        except Exception as e:
+            logger.error(f"Failed to redeem PoW solution: {e}")
             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
+            return await self._pow.request_funds(address, token)
+        except Exception as e:
+            logger.error(f"Faucet request failed: {e}")
+            return None