golem-vm-provider 0.1.38__tar.gz → 0.1.42__tar.gz

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.38
+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,8 +230,41 @@ 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 (Native ETH on L2)
+
+Enable on‑chain stream‑gated rentals funded in native ETH. Configure (env prefix `GOLEM_PROVIDER_`):
+
+- `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` — Token address; set to `0x0000000000000000000000000000000000000000` to indicate native ETH
+
+Optional background automation (all disabled by default):
+
+- `STREAM_MIN_REMAINING_SECONDS` — minimum remaining runway to keep a VM running (default 3600)
+- `STREAM_MONITOR_ENABLED` — stop VMs when remaining runway < threshold (default false)
+- `STREAM_MONITOR_INTERVAL_SECONDS` — how frequently to check runway (default 60)
+- `STREAM_WITHDRAW_ENABLED` — periodically withdraw vested funds (default false)
+- `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
+- deposit is zero, stream not started, or stream halted
+- (Optional) remaining runway < `STREAM_MIN_REMAINING_SECONDS`
+
 ## API Reference
 
 ### Create VM
@@ -245,7 +280,8 @@ Request:
     "name": "my-webserver",
     "cpu_cores": 2,
     "memory_gb": 4,
-    "storage_gb": 20
+    "storage_gb": 20,
+    "stream_id": 123            // required when STREAM_PAYMENT_ADDRESS is set
 }
 ```
 
@@ -273,6 +309,25 @@ Response:
 -   Delete VM: `DELETE /api/v1/vms/{vm_id}`
 -   Stop VM: `POST /api/v1/vms/{vm_id}/stop`
 -   Get Access Info: `GET /api/v1/vms/{vm_id}/access`
+
+### Provider Info
+
+```bash
+GET /api/v1/provider/info
+```
+
+Response:
+
+```json
+{
+  "provider_id": "0xProviderEthereumAddress",
+  "stream_payment_address": "0xStreamPayment",
+  "glm_token_address": "0x0000000000000000000000000000000000000000"  
+  
+}
+```
+
+Use this endpoint to discover the correct recipient for creating a GLM stream.
  
  ## Operations
  
@@ -282,10 +337,26 @@ Response:
 # 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
@@ -297,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.38 → golem_vm_provider-0.1.42}/README.md

@@ -185,8 +185,41 @@ 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 (Native ETH on L2)
+
+Enable on‑chain stream‑gated rentals funded in native ETH. Configure (env prefix `GOLEM_PROVIDER_`):
+
+- `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` — Token address; set to `0x0000000000000000000000000000000000000000` to indicate native ETH
+
+Optional background automation (all disabled by default):
+
+- `STREAM_MIN_REMAINING_SECONDS` — minimum remaining runway to keep a VM running (default 3600)
+- `STREAM_MONITOR_ENABLED` — stop VMs when remaining runway < threshold (default false)
+- `STREAM_MONITOR_INTERVAL_SECONDS` — how frequently to check runway (default 60)
+- `STREAM_WITHDRAW_ENABLED` — periodically withdraw vested funds (default false)
+- `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
+- deposit is zero, stream not started, or stream halted
+- (Optional) remaining runway < `STREAM_MIN_REMAINING_SECONDS`
+
 ## API Reference
 
 ### Create VM
@@ -202,7 +235,8 @@ Request:
     "name": "my-webserver",
     "cpu_cores": 2,
     "memory_gb": 4,
-    "storage_gb": 20
+    "storage_gb": 20,
+    "stream_id": 123            // required when STREAM_PAYMENT_ADDRESS is set
 }
 ```
 
@@ -230,6 +264,25 @@ Response:
 -   Delete VM: `DELETE /api/v1/vms/{vm_id}`
 -   Stop VM: `POST /api/v1/vms/{vm_id}/stop`
 -   Get Access Info: `GET /api/v1/vms/{vm_id}/access`
+
+### Provider Info
+
+```bash
+GET /api/v1/provider/info
+```
+
+Response:
+
+```json
+{
+  "provider_id": "0xProviderEthereumAddress",
+  "stream_payment_address": "0xStreamPayment",
+  "glm_token_address": "0x0000000000000000000000000000000000000000"  
+  
+}
+```
+
+Use this endpoint to discover the correct recipient for creating a GLM stream.
  
  ## Operations
  
@@ -239,10 +292,26 @@ Response:
 # 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
@@ -254,6 +323,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.38 → golem_vm_provider-0.1.42}/provider/api/models.py

@@ -17,6 +17,10 @@ class CreateVMRequest(BaseModel):
     image: str = Field(default="24.04")  # Ubuntu 24.04 LTS
     ssh_key: str = Field(..., pattern="^(ssh-rsa|ssh-ed25519) ",
                          description="SSH public key for VM access")
+    stream_id: Optional[int] = Field(
+        default=None,
+        description="On-chain StreamPayment stream id used to fund this VM"
+    )
 
     @field_validator("name")
     def validate_name(cls, v: str) -> str:
@@ -106,3 +110,9 @@ class ProviderStatusResponse(BaseModel):
     resources: Dict[str, int]
     vm_count: int
     max_vms: int
+
+
+class ProviderInfoResponse(BaseModel):
+    provider_id: str
+    stream_payment_address: str
+    glm_token_address: str

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/provider/api/routes.py

@@ -11,7 +11,8 @@ from ..container import Container
 from ..utils.logging import setup_logger
 from ..utils.ascii_art import vm_creation_animation, vm_status_change
 from ..vm.models import VMInfo, VMAccessInfo, VMConfig, VMResources, VMNotFoundError
-from .models import CreateVMRequest
+from .models import CreateVMRequest, ProviderInfoResponse
+from ..payments.blockchain_service import StreamPaymentReader
 from ..vm.service import VMService
 from ..vm.multipass_adapter import MultipassError
 
@@ -25,12 +26,22 @@ 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:
         logger.info(f"📥 Received VM creation request for '{request.name}'")
         
         resources = request.resources or VMResources()
+
+        # If payments are enabled, require a valid stream before starting
+        if settings["STREAM_PAYMENT_ADDRESS"] and settings["STREAM_PAYMENT_ADDRESS"] != "0x0000000000000000000000000000000000000000":
+            if request.stream_id is None:
+                raise HTTPException(status_code=400, detail="stream_id required when payments are enabled")
+            reader = StreamPaymentReader(settings["POLYGON_RPC_URL"], settings["STREAM_PAYMENT_ADDRESS"])
+            ok, reason = reader.verify_stream(int(request.stream_id), settings["PROVIDER_ID"])
+            if not ok:
+                raise HTTPException(status_code=400, detail=f"invalid stream: {reason}")
         
         # Create VM config
         config = VMConfig(
@@ -41,11 +52,20 @@ 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:
         logger.error(f"Failed to create VM: {e}")
         raise HTTPException(status_code=500, detail=str(e))
+    except HTTPException:
+        # Propagate explicit HTTP errors (e.g., payment gating)
+        raise
     except Exception as e:
         logger.error(f"An unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail="An unexpected error occurred")
@@ -151,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:
@@ -168,3 +193,11 @@ async def delete_vm(
     except Exception as e:
         logger.error(f"An unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail="An unexpected error occurred")
+@router.get("/provider/info", response_model=ProviderInfoResponse)
+@inject
+async def provider_info(settings: Settings = Depends(Provide[Container.config])) -> ProviderInfoResponse:
+    return ProviderInfoResponse(
+        provider_id=settings["PROVIDER_ID"],
+        stream_payment_address=settings["STREAM_PAYMENT_ADDRESS"],
+        glm_token_address=settings["GLM_TOKEN_ADDRESS"],
+    )

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/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:
@@ -135,6 +135,72 @@ class Settings(BaseSettings):
     GOLEM_BASE_RPC_URL: str = "https://ethwarsaw.holesky.golemdb.io/rpc"
     GOLEM_BASE_WS_URL: str = "wss://ethwarsaw.holesky.golemdb.io/rpc/ws"
 
+    # Polygon / Payments
+    POLYGON_RPC_URL: str = Field(
+        default="https://l2.holesky.golemdb.io/rpc",
+        description="EVM RPC URL for streaming payments (L2 by default)"
+    )
+    STREAM_PAYMENT_ADDRESS: str = Field(
+        default="0x0000000000000000000000000000000000000000",
+        description="Deployed StreamPayment contract address"
+    )
+    GLM_TOKEN_ADDRESS: str = Field(
+        default="0x0000000000000000000000000000000000000000",
+        description="Token address (0x0 means native ETH)"
+    )
+    STREAM_MIN_REMAINING_SECONDS: int = Field(
+        default=3600,
+        description="Minimum remaining seconds required to keep a VM running"
+    )
+    STREAM_MONITOR_ENABLED: bool = Field(
+        default=False,
+        description="Enable background monitor to stop VMs when runway < threshold"
+    )
+    STREAM_WITHDRAW_ENABLED: bool = Field(
+        default=False,
+        description="Enable background withdrawals for active streams"
+    )
+    STREAM_MONITOR_INTERVAL_SECONDS: int = Field(
+        default=60,
+        description="How frequently to check stream runway"
+    )
+    STREAM_WITHDRAW_INTERVAL_SECONDS: int = Field(
+        default=1800,
+        description="How frequently to attempt withdrawals"
+    )
+    STREAM_MIN_WITHDRAW_WEI: int = Field(
+        default=0,
+        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"

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/provider/container.py

@@ -14,6 +14,9 @@ from .vm.service import VMService
 from .vm.name_mapper import VMNameMapper
 from .vm.port_manager import PortManager
 from .vm.proxy_manager import PythonProxyManager
+from .payments.stream_map import StreamMap
+from .payments.blockchain_service import StreamPaymentReader, StreamPaymentClient, StreamPaymentConfig as _SPC
+from .payments.monitor import StreamMonitor
 
 
 class Container(containers.DeclarativeContainer):
@@ -49,6 +52,11 @@ class Container(containers.DeclarativeContainer):
         db_path=Path(settings.VM_DATA_DIR) / "vm_names.json",
     )
 
+    stream_map = providers.Singleton(
+        StreamMap,
+        storage_path=Path(settings.VM_DATA_DIR) / "streams.json",
+    )
+
     port_manager = providers.Singleton(
         PortManager,
         start_port=config.PORT_RANGE_START,
@@ -81,6 +89,31 @@ class Container(containers.DeclarativeContainer):
         name_mapper=vm_name_mapper,
     )
 
+    # Payments
+    stream_reader = providers.Factory(
+        StreamPaymentReader,
+        rpc_url=config.POLYGON_RPC_URL,
+        contract_address=config.STREAM_PAYMENT_ADDRESS,
+    )
+    stream_client = providers.Factory(
+        StreamPaymentClient,
+        cfg=providers.Callable(
+            lambda rpc, addr, pk: _SPC(rpc_url=rpc, contract_address=addr, private_key=pk),
+            config.POLYGON_RPC_URL,
+            config.STREAM_PAYMENT_ADDRESS,
+            config.ETHEREUM_PRIVATE_KEY,
+        ),
+    )
+
+    stream_monitor = providers.Singleton(
+        StreamMonitor,
+        stream_map=stream_map,
+        vm_service=vm_service,
+        reader=stream_reader,
+        client=stream_client,
+        settings=config,
+    )
+
     provider_service = providers.Singleton(
         ProviderService,
         vm_service=vm_service,

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/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),

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/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

golem_vm_provider-0.1.42/provider/payments/blockchain_service.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from web3 import Web3
+from eth_account import Account
+from golem_streaming_abi import STREAM_PAYMENT_ABI
+
+
+ # ABI imported from shared package
+
+
+@dataclass
+class StreamPaymentConfig:
+    rpc_url: str
+    contract_address: str
+    private_key: str
+
+
+class StreamPaymentClient:
+    def __init__(self, cfg: StreamPaymentConfig):
+        self.web3 = Web3(Web3.HTTPProvider(cfg.rpc_url))
+        self.account = Account.from_key(cfg.private_key)
+        self.web3.eth.default_account = self.account.address
+        self.contract = self.web3.eth.contract(
+            address=Web3.to_checksum_address(cfg.contract_address), abi=STREAM_PAYMENT_ABI
+        )
+
+    def _send(self, fn) -> Dict[str, Any]:
+        tx = fn.build_transaction(
+            {
+                "from": self.account.address,
+                "nonce": self.web3.eth.get_transaction_count(self.account.address),
+            }
+        )
+        if hasattr(self.account, "sign_transaction"):
+            signed = self.account.sign_transaction(tx)
+            tx_hash = self.web3.eth.send_raw_transaction(signed.rawTransaction)
+        else:
+            tx_hash = self.web3.eth.send_transaction(tx)
+        receipt = self.web3.eth.wait_for_transaction_receipt(tx_hash)
+        return {"transactionHash": tx_hash.hex(), "status": receipt.status}
+
+    def withdraw(self, stream_id: int) -> str:
+        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):
+        self.web3 = Web3(Web3.HTTPProvider(rpc_url))
+        self.contract = self.web3.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=STREAM_PAYMENT_ABI
+        )
+
+    def get_stream(self, stream_id: int) -> dict:
+        token, sender, recipient, startTime, stopTime, ratePerSecond, deposit, withdrawn, halted = (
+            self.contract.functions.streams(int(stream_id)).call()
+        )
+        return {
+            "token": token,
+            "sender": sender,
+            "recipient": recipient,
+            "startTime": int(startTime),
+            "stopTime": int(stopTime),
+            "ratePerSecond": int(ratePerSecond),
+            "deposit": int(deposit),
+            "withdrawn": int(withdrawn),
+            "halted": bool(halted),
+        }
+
+    def verify_stream(self, stream_id: int, expected_recipient: str) -> tuple[bool, str]:
+        try:
+            s = self.get_stream(stream_id)
+        except Exception as e:
+            return False, f"stream lookup failed: {e}"
+        if s["recipient"].lower() != expected_recipient.lower():
+            return False, "recipient mismatch"
+        if s["deposit"] <= 0:
+            return False, "no deposit"
+        now = int(self.web3.eth.get_block("latest")["timestamp"])
+        if s["startTime"] > now:
+            return False, "stream not started"
+        if s["halted"]:
+            return False, "stream halted"
+        return True, "ok"
+
+    # Reader should remain read-only; no terminate here

golem_vm_provider-0.1.42/provider/payments/monitor.py

@@ -0,0 +1,67 @@
+import asyncio
+from typing import Optional
+
+from ..utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class StreamMonitor:
+    def __init__(self, *, stream_map, vm_service, reader, client, settings):
+        self.stream_map = stream_map
+        self.vm_service = vm_service
+        self.reader = reader
+        self.client = client
+        self.settings = settings
+        self._task: Optional[asyncio.Task] = None
+
+    def start(self):
+        if self.settings.STREAM_MONITOR_ENABLED or self.settings.STREAM_WITHDRAW_ENABLED:
+            self._task = asyncio.create_task(self._run(), name="stream-monitor")
+
+    async def stop(self):
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+
+    async def _run(self):
+        last_withdraw = 0
+        while True:
+            try:
+                await asyncio.sleep(self.settings.STREAM_MONITOR_INTERVAL_SECONDS)
+                items = await self.stream_map.all_items()
+                now = int(self.reader.web3.eth.get_block("latest")["timestamp"]) if items else 0
+                for vm_id, stream_id in items.items():
+                    try:
+                        s = self.reader.get_stream(stream_id)
+                    except Exception as e:
+                        logger.warning(f"stream {stream_id} lookup failed: {e}")
+                        continue
+                    # Stop VM if remaining runway < threshold
+                    remaining = max(s["stopTime"] - now, 0)
+                    if self.settings.STREAM_MONITOR_ENABLED and remaining < self.settings.STREAM_MIN_REMAINING_SECONDS:
+                        logger.info(f"Stopping VM {vm_id} due to low stream runway ({remaining}s)")
+                        try:
+                            await self.vm_service.stop_vm(vm_id)
+                        except Exception as e:
+                            logger.warning(f"stop_vm failed for {vm_id}: {e}")
+                    # Withdraw if enough vested and configured
+                    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)
+                        # 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}")

golem_vm_provider-0.1.42/provider/payments/stream_map.py

@@ -0,0 +1,40 @@
+import asyncio
+import json
+from pathlib import Path
+from typing import Dict, Optional
+
+
+class StreamMap:
+    def __init__(self, storage_path: Path):
+        self._path = storage_path
+        self._lock = asyncio.Lock()
+        self._data: Dict[str, int] = {}
+        if self._path.exists():
+            try:
+                self._data = json.loads(self._path.read_text())
+            except Exception:
+                self._data = {}
+
+    async def set(self, vm_id: str, stream_id: int) -> None:
+        async with self._lock:
+            self._data[vm_id] = int(stream_id)
+            self._persist()
+
+    async def get(self, vm_id: str) -> Optional[int]:
+        return self._data.get(vm_id)
+
+    async def remove(self, vm_id: str) -> None:
+        async with self._lock:
+            if vm_id in self._data:
+                del self._data[vm_id]
+                self._persist()
+
+    async def all_items(self) -> Dict[str, int]:
+        return dict(self._data)
+
+    def _persist(self) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self._path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(self._data, indent=2))
+        tmp.replace(self._path)
+

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/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

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/provider/service.py

@@ -17,6 +17,7 @@ class ProviderService:
         self.advertisement_service = advertisement_service
         self.port_manager = port_manager
         self._pricing_updater: PricingAutoUpdater | None = None
+        self._stream_monitor = None
 
     async def setup(self, app: FastAPI):
         """Setup and initialize the provider components."""
@@ -43,6 +44,13 @@ class ProviderService:
             self._pricing_updater = PricingAutoUpdater(on_updated_callback=_on_price_updated)
             asyncio.create_task(self._pricing_updater.start())
 
+            # Start stream monitor if enabled
+            from .container import Container
+            from .config import settings as cfg
+            if cfg.STREAM_MONITOR_ENABLED or cfg.STREAM_WITHDRAW_ENABLED:
+                self._stream_monitor = app.container.stream_monitor()
+                self._stream_monitor.start()
+
             # Check wallet balance and request funds if needed
             faucet_client = FaucetClient(
                 faucet_url=settings.FAUCET_URL,
@@ -64,6 +72,8 @@ class ProviderService:
         await self.vm_service.provider.cleanup()
         if self._pricing_updater:
             self._pricing_updater.stop()
+        if self._stream_monitor:
+            await self._stream_monitor.stop()
         logger.success("✨ Provider cleanup complete")
 
     def _setup_directories(self):

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/provider/vm/service.py

@@ -19,10 +19,12 @@ class VMService:
         provider: VMProvider,
         resource_tracker: ResourceTracker,
         name_mapper: VMNameMapper,
+        blockchain_client: object | None = None,
     ):
         self.provider = provider
         self.resource_tracker = resource_tracker
         self.name_mapper = name_mapper
+        self.blockchain_client = blockchain_client
 
     async def create_vm(self, config: VMConfig) -> VMInfo:
         """Create a new VM."""
@@ -59,6 +61,13 @@ class VMService:
             vm_info = await self.provider.get_vm_status(multipass_name)
             await self.provider.delete_vm(multipass_name)
             await self.resource_tracker.deallocate(vm_info.resources, vm_id)
+            # Optional: best-effort on-chain termination if we have a mapping
+            try:
+                if self.blockchain_client:
+                    # In future: look up stream id associated to this vm_id
+                    pass
+            except Exception:
+                pass
         except VMNotFoundError:
             logger.warning(f"VM {multipass_name} not found on provider, cleaning up resources")
             # If the VM is not found, we still need to deallocate the resources we have tracked for it
@@ -74,7 +83,15 @@ class VMService:
         multipass_name = await self.name_mapper.get_multipass_name(vm_id)
         if not multipass_name:
             raise VMNotFoundError(f"VM {vm_id} not found")
-        return await self.provider.stop_vm(multipass_name)
+        vm = await self.provider.stop_vm(multipass_name)
+        # Optional: best-effort withdraw for active stream
+        try:
+            if self.blockchain_client:
+                # In future: look up stream id associated to this vm_id
+                pass
+        except Exception:
+            pass
+        return vm
  
     async def list_vms(self) -> List[VMInfo]:
         """List all VMs."""
@@ -95,4 +112,4 @@ class VMService:
         await self.provider.initialize()
 
     async def shutdown(self):
-        await self.provider.cleanup()
+        await self.provider.cleanup()

{golem_vm_provider-0.1.38 → golem_vm_provider-0.1.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "golem-vm-provider"
-version = "0.1.38"
+version = "0.1.42"
 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"
@@ -21,7 +21,6 @@ packages = [
 
 [tool.poetry.scripts]
 golem-provider = "provider.main:cli"
-dev = "provider.main:dev"
 
 [tool.poetry.dependencies]
 python = "^3.11"
@@ -46,10 +45,12 @@ typer = "^0.4.0"
 web3 = "==7.13.0"
 golem-base-sdk = "==0.1.0"
 dependency-injector = "^4.41.0"
+golem-streaming-abi = ">=0.1.0,<0.2.0"
+golem-faucet = ">=0.1.0,<0.2.0"
 
 [tool.poetry.group.dev.dependencies]
-pytest = "^7.0.0"
-pytest-asyncio = "^0.18.0"
+pytest = "^8.2.0"
+pytest-asyncio = "^1.1.0"
 pytest-mock = "^3.8.2"
 pytest-cov = "^3.0.0"
 black = "^22.3.0"