golem-vm-provider 0.1.43__tar.gz → 0.1.44__tar.gz

{golem_vm_provider-0.1.43 → golem_vm_provider-0.1.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.43
+Version: 0.1.44
 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
@@ -238,11 +238,12 @@ 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_`):
+Enable on‑chain stream‑gated rentals funded in native ETH. By default, the provider auto‑loads the StreamPayment contract from `contracts/deployments/l2.json` and enables payments out of the box. Configure/override (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
+- `POLYGON_RPC_URL` — EVM RPC URL (default L2 RPC)
+- `STREAM_PAYMENT_ADDRESS` — StreamPayment address (defaults from `contracts/deployments/l2.json`)
+- `GLM_TOKEN_ADDRESS` — Token address (defaults from `contracts/deployments/l2.json`; `0x0` means native ETH)
+  - Optional override of deployments directory: set `GOLEM_DEPLOYMENTS_DIR` to a folder containing `l2.json`.
 
 Optional background automation (all disabled by default):
 
@@ -255,7 +256,7 @@ Optional background automation (all disabled by default):
 
 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.
+- The provider exposes `GET /api/v1/provider/info` returning `provider_id`, `stream_payment_address`, and `glm_token_address`. 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.
 
@@ -328,7 +329,44 @@ Response:
 ```
 
 Use this endpoint to discover the correct recipient for creating a GLM stream.
- 
+
+### Payment Streams
+
+- Get a VM’s stream status: `GET /api/v1/vms/{vm_id}/stream`
+- List all mapped streams: `GET /api/v1/payments/streams`
+
+Response (per stream):
+
+```json
+{
+  "vm_id": "golem-my-webserver-20250219-130424",
+  "stream_id": 123,
+  "verified": true,
+  "reason": "ok",
+  "chain": {
+    "token": "0x0000000000000000000000000000000000000000",
+    "sender": "0x...",
+    "recipient": "0xProviderEthereumAddress",
+    "startTime": 1700000000,
+    "stopTime": 1700007200,
+    "ratePerSecond": 12345,
+    "deposit": 1000000000000000000,
+    "withdrawn": 0,
+    "halted": false
+  },
+  "computed": {
+    "now": 1700003600,
+    "remaining_seconds": 3600,
+    "vested_wei": 44442000,
+    "withdrawable_wei": 44442000
+  }
+}
+```
+
+Notes:
+- Endpoints return 400 when streaming is disabled (zero `STREAM_PAYMENT_ADDRESS`).
+- In development mode (`GOLEM_PROVIDER_ENVIRONMENT=development`) additional debug logs are emitted around stream verification and monitor ticks.
+
  ## Operations
  
 ### Starting the Provider
@@ -382,6 +420,22 @@ Defaults:
 - 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`.
 
+### Streams (CLI)
+
+- List all mapped streams with computed fields:
+
+```bash
+poetry run golem-provider streams list
+# or JSON
+poetry run golem-provider streams list --json
+```
+
+- Show one VM’s stream (VM id = `requestor_name`):
+
+```bash
+poetry run golem-provider streams show <vm_id>
+```
+
 ### Resource Advertisement Flow
 
 ```mermaid

{golem_vm_provider-0.1.43 → golem_vm_provider-0.1.44}/README.md

@@ -193,11 +193,12 @@ 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_`):
+Enable on‑chain stream‑gated rentals funded in native ETH. By default, the provider auto‑loads the StreamPayment contract from `contracts/deployments/l2.json` and enables payments out of the box. Configure/override (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
+- `POLYGON_RPC_URL` — EVM RPC URL (default L2 RPC)
+- `STREAM_PAYMENT_ADDRESS` — StreamPayment address (defaults from `contracts/deployments/l2.json`)
+- `GLM_TOKEN_ADDRESS` — Token address (defaults from `contracts/deployments/l2.json`; `0x0` means native ETH)
+  - Optional override of deployments directory: set `GOLEM_DEPLOYMENTS_DIR` to a folder containing `l2.json`.
 
 Optional background automation (all disabled by default):
 
@@ -210,7 +211,7 @@ Optional background automation (all disabled by default):
 
 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.
+- The provider exposes `GET /api/v1/provider/info` returning `provider_id`, `stream_payment_address`, and `glm_token_address`. 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.
 
@@ -283,7 +284,44 @@ Response:
 ```
 
 Use this endpoint to discover the correct recipient for creating a GLM stream.
- 
+
+### Payment Streams
+
+- Get a VM’s stream status: `GET /api/v1/vms/{vm_id}/stream`
+- List all mapped streams: `GET /api/v1/payments/streams`
+
+Response (per stream):
+
+```json
+{
+  "vm_id": "golem-my-webserver-20250219-130424",
+  "stream_id": 123,
+  "verified": true,
+  "reason": "ok",
+  "chain": {
+    "token": "0x0000000000000000000000000000000000000000",
+    "sender": "0x...",
+    "recipient": "0xProviderEthereumAddress",
+    "startTime": 1700000000,
+    "stopTime": 1700007200,
+    "ratePerSecond": 12345,
+    "deposit": 1000000000000000000,
+    "withdrawn": 0,
+    "halted": false
+  },
+  "computed": {
+    "now": 1700003600,
+    "remaining_seconds": 3600,
+    "vested_wei": 44442000,
+    "withdrawable_wei": 44442000
+  }
+}
+```
+
+Notes:
+- Endpoints return 400 when streaming is disabled (zero `STREAM_PAYMENT_ADDRESS`).
+- In development mode (`GOLEM_PROVIDER_ENVIRONMENT=development`) additional debug logs are emitted around stream verification and monitor ticks.
+
  ## Operations
  
 ### Starting the Provider
@@ -337,6 +375,22 @@ Defaults:
 - 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`.
 
+### Streams (CLI)
+
+- List all mapped streams with computed fields:
+
+```bash
+poetry run golem-provider streams list
+# or JSON
+poetry run golem-provider streams list --json
+```
+
+- Show one VM’s stream (VM id = `requestor_name`):
+
+```bash
+poetry run golem-provider streams show <vm_id>
+```
+
 ### Resource Advertisement Flow
 
 ```mermaid

{golem_vm_provider-0.1.43 → golem_vm_provider-0.1.44}/provider/api/models.py

@@ -116,3 +116,31 @@ class ProviderInfoResponse(BaseModel):
     provider_id: str
     stream_payment_address: str
     glm_token_address: str
+
+
+class StreamOnChain(BaseModel):
+    token: str
+    sender: str
+    recipient: str
+    startTime: int
+    stopTime: int
+    ratePerSecond: int
+    deposit: int
+    withdrawn: int
+    halted: bool
+
+
+class StreamComputed(BaseModel):
+    now: int
+    remaining_seconds: int
+    vested_wei: int
+    withdrawable_wei: int
+
+
+class StreamStatus(BaseModel):
+    vm_id: str
+    stream_id: int
+    chain: StreamOnChain
+    computed: StreamComputed
+    verified: bool
+    reason: str

{golem_vm_provider-0.1.43 → golem_vm_provider-0.1.44}/provider/api/routes.py

@@ -11,7 +11,7 @@ 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, ProviderInfoResponse
+from .models import CreateVMRequest, ProviderInfoResponse, StreamStatus, StreamOnChain, StreamComputed
 from ..payments.blockchain_service import StreamPaymentReader
 from ..vm.service import VMService
 from ..vm.multipass_adapter import MultipassError
@@ -40,6 +40,17 @@ async def create_vm(
                 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"])
+            try:
+                s = reader.get_stream(int(request.stream_id))
+                now = int(reader.web3.eth.get_block("latest")["timestamp"])  # type: ignore[attr-defined]
+                remaining = max(int(s["stopTime"]) - now, 0)
+                logger.info(
+                    f"💸 Stream check id={int(request.stream_id)} ok={ok} reason='{reason}' "
+                    f"start={s['startTime']} stop={s['stopTime']} rate={s['ratePerSecond']} deposit={s['deposit']} withdrawn={s['withdrawn']} remaining={remaining}s"
+                )
+            except Exception:
+                # Best-effort logging; creation will continue/fail based on ok
+                pass
             if not ok:
                 raise HTTPException(status_code=400, detail=f"invalid stream: {reason}")
         
@@ -201,3 +212,72 @@ async def provider_info(settings: Settings = Depends(Provide[Container.config]))
         stream_payment_address=settings["STREAM_PAYMENT_ADDRESS"],
         glm_token_address=settings["GLM_TOKEN_ADDRESS"],
     )
+
+
+@router.get("/vms/{requestor_name}/stream", response_model=StreamStatus)
+@inject
+async def get_vm_stream_status(
+    requestor_name: str,
+    settings: Settings = Depends(Provide[Container.config]),
+    stream_map = Depends(Provide[Container.stream_map]),
+) -> StreamStatus:
+    """Return on-chain stream status for a VM (if mapped)."""
+    if not settings["STREAM_PAYMENT_ADDRESS"] or settings["STREAM_PAYMENT_ADDRESS"] == "0x0000000000000000000000000000000000000000":
+        raise HTTPException(status_code=400, detail="streaming payments not enabled on this provider")
+    stream_id = await stream_map.get(requestor_name)
+    if stream_id is None:
+        raise HTTPException(status_code=404, detail="no stream mapped for this VM")
+    reader = StreamPaymentReader(settings["POLYGON_RPC_URL"], settings["STREAM_PAYMENT_ADDRESS"])
+    try:
+        s = reader.get_stream(int(stream_id))
+    except Exception as e:
+        raise HTTPException(status_code=502, detail=f"stream lookup failed: {e}")
+    ok, reason = reader.verify_stream(int(stream_id), settings["PROVIDER_ID"])
+    now = int(reader.web3.eth.get_block("latest")["timestamp"])  # type: ignore[attr-defined]
+    vested = max(min(now, int(s["stopTime"])) - int(s["startTime"]), 0) * int(s["ratePerSecond"])  # type: ignore[operator]
+    withdrawable = max(int(vested) - int(s["withdrawn"]), 0)
+    remaining = max(int(s["stopTime"]) - now, 0)
+    return StreamStatus(
+        vm_id=requestor_name,
+        stream_id=int(stream_id),
+        chain=StreamOnChain(**s),
+        computed=StreamComputed(now=now, remaining_seconds=remaining, vested_wei=int(vested), withdrawable_wei=int(withdrawable)),
+        verified=bool(ok),
+        reason=str(reason),
+    )
+
+
+@router.get("/payments/streams", response_model=List[StreamStatus])
+@inject
+async def list_stream_statuses(
+    settings: Settings = Depends(Provide[Container.config]),
+    stream_map = Depends(Provide[Container.stream_map]),
+) -> List[StreamStatus]:
+    """List stream status for all mapped VMs."""
+    if not settings["STREAM_PAYMENT_ADDRESS"] or settings["STREAM_PAYMENT_ADDRESS"] == "0x0000000000000000000000000000000000000000":
+        raise HTTPException(status_code=400, detail="streaming payments not enabled on this provider")
+    reader = StreamPaymentReader(settings["POLYGON_RPC_URL"], settings["STREAM_PAYMENT_ADDRESS"])
+    items = await stream_map.all_items()
+    now = int(reader.web3.eth.get_block("latest")["timestamp"]) if items else 0  # type: ignore[attr-defined]
+    resp: List[StreamStatus] = []
+    for vm_id, stream_id in items.items():
+        try:
+            s = reader.get_stream(int(stream_id))
+            ok, reason = reader.verify_stream(int(stream_id), settings["PROVIDER_ID"])
+            vested = max(min(now, int(s["stopTime"])) - int(s["startTime"]), 0) * int(s["ratePerSecond"])  # type: ignore[operator]
+            withdrawable = max(int(vested) - int(s["withdrawn"]), 0)
+            remaining = max(int(s["stopTime"]) - now, 0)
+            resp.append(
+                StreamStatus(
+                    vm_id=vm_id,
+                    stream_id=int(stream_id),
+                    chain=StreamOnChain(**s),
+                    computed=StreamComputed(now=now, remaining_seconds=remaining, vested_wei=int(vested), withdrawable_wei=int(withdrawable)),
+                    verified=bool(ok),
+                    reason=str(reason),
+                )
+            )
+        except Exception as e:
+            logger.warning(f"stream {stream_id} lookup failed: {e}")
+            continue
+    return resp

{golem_vm_provider-0.1.43 → golem_vm_provider-0.1.44}/provider/config.py

@@ -1,4 +1,5 @@
 import os
+import json
 from pathlib import Path
 from typing import Optional
 import uuid
@@ -141,12 +142,12 @@ class Settings(BaseSettings):
         description="EVM RPC URL for streaming payments (L2 by default)"
     )
     STREAM_PAYMENT_ADDRESS: str = Field(
-        default="0x0000000000000000000000000000000000000000",
-        description="Deployed StreamPayment contract address"
+        default="",
+        description="Deployed StreamPayment contract address (defaults to contracts/deployments/l2.json)"
     )
     GLM_TOKEN_ADDRESS: str = Field(
-        default="0x0000000000000000000000000000000000000000",
-        description="Token address (0x0 means native ETH)"
+        default="",
+        description="Token address (0x0 means native ETH). Defaults from l2.json"
     )
     STREAM_MIN_REMAINING_SECONDS: int = Field(
         default=3600,
@@ -201,6 +202,55 @@ class Settings(BaseSettings):
                 return os.environ[key]
         return v
 
+    @staticmethod
+    def _load_l2_deployment() -> 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.
+        """
+        try:
+            # Allow override via env
+            base = os.environ.get("GOLEM_DEPLOYMENTS_DIR")
+            if base:
+                path = Path(base) / "l2.json"
+            else:
+                # repo root = ../../ from this file
+                path = Path(__file__).resolve().parents[2] / "contracts" / "deployments" / "l2.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]
+                        data = json.load(fh)
+                except Exception:
+                    return None, None
+            else:
+                data = json.loads(path.read_text())
+            sp = data.get("StreamPayment", {})
+            addr = sp.get("address")
+            token = sp.get("glmToken")
+            if isinstance(addr, str) and addr:
+                return addr, token or "0x0000000000000000000000000000000000000000"
+        except Exception:
+            pass
+        return None, None
+
+    @field_validator("STREAM_PAYMENT_ADDRESS", mode='before')
+    @classmethod
+    def default_stream_addr(cls, v: str) -> str:
+        if v:
+            return v
+        addr, _ = Settings._load_l2_deployment()
+        return addr or "0x0000000000000000000000000000000000000000"
+
+    @field_validator("GLM_TOKEN_ADDRESS", mode='before')
+    @classmethod
+    def default_token_addr(cls, v: str) -> str:
+        if v:
+            return v
+        _, token = Settings._load_l2_deployment()
+        return token or "0x0000000000000000000000000000000000000000"
+
     # VM Settings
     MAX_VMS: int = 10
     DEFAULT_VM_IMAGE: str = "ubuntu:24.04"

golem_vm_provider-0.1.44/provider/data/deployments/l2.json

@@ -0,0 +1,9 @@
+{
+  "network": "l2",
+  "timestamp": "",
+  "StreamPayment": {
+    "address": "0x0281B792b5491E3548c8Fc17C24A2e0Cb99FbeC2",
+    "oracle": "0xDd329f6EDf93637634E8862d34c3909d298A7055",
+    "glmToken": "0x0000000000000000000000000000000000000000"
+  }
+}

{golem_vm_provider-0.1.43 → golem_vm_provider-0.1.44}/provider/main.py

@@ -123,8 +123,10 @@ 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)")
+streams_app = typer.Typer(help="Inspect payment streams")
 cli.add_typer(pricing_app, name="pricing")
 cli.add_typer(wallet_app, name="wallet")
+cli.add_typer(streams_app, name="streams")
 
 def print_version(ctx: typer.Context, value: bool):
     if not value:
@@ -185,6 +187,108 @@ def wallet_faucet_l2():
         print(f"Error: {e}")
         raise typer.Exit(code=1)
 
+
+@streams_app.command("list")
+def streams_list(json_out: bool = typer.Option(False, "--json", help="Output in JSON")):
+    """List all mapped streams with computed status."""
+    from .container import Container
+    from .config import settings
+    from .payments.blockchain_service import StreamPaymentReader
+    import json as _json
+    try:
+        if not settings.STREAM_PAYMENT_ADDRESS or settings.STREAM_PAYMENT_ADDRESS == "0x0000000000000000000000000000000000000000":
+            print("Streaming payments are disabled on this provider.")
+            raise typer.Exit(code=1)
+        c = Container()
+        c.config.from_pydantic(settings)
+        stream_map = c.stream_map()
+        reader = StreamPaymentReader(settings.POLYGON_RPC_URL, settings.STREAM_PAYMENT_ADDRESS)
+        items = asyncio.run(stream_map.all_items())
+        now = int(reader.web3.eth.get_block("latest")["timestamp"]) if items else 0
+        rows = []
+        for vm_id, stream_id in items.items():
+            try:
+                s = reader.get_stream(int(stream_id))
+                vested = max(min(now, int(s["stopTime"])) - int(s["startTime"]), 0) * int(s["ratePerSecond"])  # type: ignore
+                withdrawable = max(int(vested) - int(s["withdrawn"]), 0)
+                remaining = max(int(s["stopTime"]) - now, 0)
+                ok, reason = reader.verify_stream(int(stream_id), settings.PROVIDER_ID)
+                rows.append({
+                    "vm_id": vm_id,
+                    "stream_id": int(stream_id),
+                    "recipient": s["recipient"],
+                    "start": int(s["startTime"]),
+                    "stop": int(s["stopTime"]),
+                    "rate": int(s["ratePerSecond"]),
+                    "deposit": int(s["deposit"]),
+                    "withdrawn": int(s["withdrawn"]),
+                    "remaining": remaining,
+                    "verified": bool(ok),
+                    "reason": reason,
+                    "withdrawable": int(withdrawable),
+                })
+            except Exception as e:
+                rows.append({"vm_id": vm_id, "stream_id": int(stream_id), "error": str(e)})
+        if json_out:
+            print(_json.dumps({"streams": rows}, indent=2))
+            return
+        if not rows:
+            print("No streams mapped.")
+            return
+        print("\nStreams (VM → stream_id, remaining s, verified):")
+        for r in rows:
+            if "error" in r:
+                print(f"- {r['vm_id']}: {r['stream_id']} ERROR: {r['error']}")
+            else:
+                print(f"- {r['vm_id']}: {r['stream_id']} remaining={r['remaining']}s verified={r['verified']} reason={r['reason']} withdrawable={r['withdrawable']}")
+    except Exception as e:
+        print(f"Error: {e}")
+        raise typer.Exit(code=1)
+
+
+@streams_app.command("show")
+def streams_show(vm_id: str = typer.Argument(..., help="VM id (requestor_name)"), json_out: bool = typer.Option(False, "--json")):
+    """Show a single VM's stream status."""
+    from .container import Container
+    from .config import settings
+    from .payments.blockchain_service import StreamPaymentReader
+    import json as _json
+    try:
+        c = Container()
+        c.config.from_pydantic(settings)
+        stream_map = c.stream_map()
+        sid = asyncio.run(stream_map.get(vm_id))
+        if sid is None:
+            print("No stream mapped for this VM.")
+            raise typer.Exit(code=1)
+        reader = StreamPaymentReader(settings.POLYGON_RPC_URL, settings.STREAM_PAYMENT_ADDRESS)
+        s = reader.get_stream(int(sid))
+        now = int(reader.web3.eth.get_block("latest")["timestamp"])  # type: ignore
+        vested = max(min(now, int(s["stopTime"])) - int(s["startTime"]), 0) * int(s["ratePerSecond"])  # type: ignore
+        withdrawable = max(int(vested) - int(s["withdrawn"]), 0)
+        remaining = max(int(s["stopTime"]) - now, 0)
+        ok, reason = reader.verify_stream(int(sid), settings.PROVIDER_ID)
+        out = {
+            "vm_id": vm_id,
+            "stream_id": int(sid),
+            "chain": s,
+            "computed": {
+                "now": now,
+                "remaining_seconds": remaining,
+                "vested_wei": int(vested),
+                "withdrawable_wei": int(withdrawable),
+            },
+            "verified": bool(ok),
+            "reason": reason,
+        }
+        if json_out:
+            print(_json.dumps(out, indent=2))
+        else:
+            print(f"VM {vm_id}: stream {sid} remaining={remaining}s verified={ok} withdrawable={withdrawable}")
+    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."),

{golem_vm_provider-0.1.43 → golem_vm_provider-0.1.44}/provider/payments/monitor.py

@@ -17,6 +17,10 @@ class StreamMonitor:
 
     def start(self):
         if self.settings.STREAM_MONITOR_ENABLED or self.settings.STREAM_WITHDRAW_ENABLED:
+            logger.info(
+                f"⏱️ Stream monitor enabled (check={self.settings.STREAM_MONITOR_ENABLED}, withdraw={self.settings.STREAM_WITHDRAW_ENABLED}) "
+                f"interval={self.settings.STREAM_MONITOR_INTERVAL_SECONDS}s"
+            )
             self._task = asyncio.create_task(self._run(), name="stream-monitor")
 
     async def stop(self):
@@ -34,6 +38,7 @@ class StreamMonitor:
                 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
+                logger.debug(f"stream monitor tick: {len(items)} streams, now={now}")
                 for vm_id, stream_id in items.items():
                     try:
                         s = self.reader.get_stream(stream_id)
@@ -42,6 +47,10 @@ class StreamMonitor:
                         continue
                     # Stop VM if remaining runway < threshold
                     remaining = max(s["stopTime"] - now, 0)
+                    logger.debug(
+                        f"stream {stream_id} for VM {vm_id}: start={s['startTime']} stop={s['stopTime']} "
+                        f"rate={s['ratePerSecond']} withdrawn={s['withdrawn']} halted={s['halted']} remaining={remaining}s"
+                    )
                     if self.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:
@@ -52,6 +61,7 @@ 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)
+                        logger.debug(f"withdraw check stream {stream_id}: vested={vested} withdrawable={withdrawable}")
                         # Enforce a minimum interval between withdrawals
                         if withdrawable >= self.settings.STREAM_MIN_WITHDRAW_WEI and (
                             now - last_withdraw >= self.settings.STREAM_WITHDRAW_INTERVAL_SECONDS

{golem_vm_provider-0.1.43 → golem_vm_provider-0.1.44}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "golem-vm-provider"
-version = "0.1.43"
+version = "0.1.44"
 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"
@@ -19,6 +19,11 @@ packages = [
     { include = "provider" }
 ]
 
+# Include package data (deployment JSON)
+include = [
+    { path = "provider/data/deployments/l2.json", format = "wheel" },
+]
+
 [tool.poetry.scripts]
 golem-provider = "provider.main:cli"