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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.42
+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.42.dist-info → golem_vm_provider-0.1.44.dist-info}/RECORD

@@ -1,21 +1,22 @@
 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=DODju_SOgfkyeZv9zLTuAXbyvdaWRbU4kHZpON_GeMg,8288
-provider/config.py,sha256=u7Y0w9-s8iitQzQ3R0ztgYSfq_WeSRUYzBRTor8GAlY,22666
+provider/api/models.py,sha256=CmfgXqSH3m0HLqY6JvUFI-2IrdGf3EhNKtZ5kbIAX-U,4304
+provider/api/routes.py,sha256=Cv2oLkMDXY_65xlNSvmJAG1dzmlibxbPHy_J42kRJsA,12583
+provider/config.py,sha256=nabZhzgUYE7GEdCou_uEzy3KGWhuqEhwKwasxYOEedI,24636
 provider/container.py,sha256=81x5LiA-qjYN1Uh_JdOxqvuIXiNDr9X3OXNN0VqYFCI,3681
+provider/data/deployments/l2.json,sha256=XTNN2C5LkBfp4YbDKdUKfWMdp1fKnfv8D3TgcwVWxtQ,249
 provider/discovery/__init__.py,sha256=Y6o8RxGevBpuQS3k32y-zSVbP6HBXG3veBl9ElVPKaU,349
 provider/discovery/advertiser.py,sha256=o-LiDl1j0lXMUU0-zPe3qerjpoD2360EA60Y_V_VeBc,6571
-provider/discovery/golem_base_advertiser.py,sha256=0I6V73GL671c8mQNpb92sdyboXzbJuRJdv06QS7MuBQ,6942
+provider/discovery/golem_base_advertiser.py,sha256=fPjBScWDDX5behuQfOFqGTp0tL-sXpLXGbnx3smRmfc,7243
 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=eS_rqvC9bCXdJfYg-sNYt02SGPdodgPGa350SWcd1os,14271
+provider/main.py,sha256=TEk9J792BsSTQ0MstK_D6-Ls-9hAIDI6S4Cu6Qwu0dY,19012
 provider/network/port_verifier.py,sha256=3l6WNwBHydggJRFYkAsuBp1eCxaU619kjWuM-zSVj2o,13267
 provider/payments/blockchain_service.py,sha256=Qq01M7N_gzUidnXBngDcNoBRs_sHKaTpvSFKz6wEAMk,3363
-provider/payments/monitor.py,sha256=6zzW275ktSHcYiIXuyThr-UA-JR7VoHw2Hk1qAUCb-U,3058
+provider/payments/monitor.py,sha256=TD88OrVfqGdzgfZkGNcCQMnGr0MLoj2p-bunDoalT8M,3814
 provider/payments/stream_map.py,sha256=qk6Y8hS72DplAifZ0ZMWPHBAyc_3IWIQyWUBuCU3_To,1191
 provider/security/ethereum.py,sha256=EwPZj4JR8OEpto6LhKjuuT3Z9pBX6P7-UQaqJtqFkYQ,1242
 provider/security/faucet.py,sha256=8T4lW1fVQgUk8EQILgbrr9UUosw9e7eA40tlZ2_KCPQ,4368
@@ -37,7 +38,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.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.44.dist-info/METADATA,sha256=G0kZDN-BIOXkC8yInfrrd8yOEMl5HWkA2mptK7Qf7R8,16589
+golem_vm_provider-0.1.44.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.44.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
+golem_vm_provider-0.1.44.dist-info/RECORD,,

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

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

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"

provider/data/deployments/l2.json

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

provider/discovery/golem_base_advertiser.py

@@ -64,6 +64,7 @@ class GolemBaseAdvertiser(Advertiser):
         try:
             existing_keys = await get_provider_entity_keys(self.client, settings.PROVIDER_ID)
 
+            # String annotations (metadata + prices as strings; on-chain numeric annotations must be ints)
             string_annotations = [
                 Annotation(key="golem_type", value="provider"),
                 Annotation(key="golem_network", value=settings.NETWORK),
@@ -72,17 +73,19 @@ class GolemBaseAdvertiser(Advertiser):
                 Annotation(key="golem_country", value=settings.PROVIDER_COUNTRY),
                 Annotation(key="golem_provider_name", value=settings.PROVIDER_NAME),
                 Annotation(key="golem_price_currency", value="USD/GLM"),
+                # Prices must be strings to avoid RLP sedes errors (ints only allowed for numeric annotations)
+                Annotation(key="golem_price_usd_core_month", value=str(float(settings.PRICE_USD_PER_CORE_MONTH))),
+                Annotation(key="golem_price_usd_ram_gb_month", value=str(float(settings.PRICE_USD_PER_GB_RAM_MONTH))),
+                Annotation(key="golem_price_usd_storage_gb_month", value=str(float(settings.PRICE_USD_PER_GB_STORAGE_MONTH))),
+                Annotation(key="golem_price_glm_core_month", value=str(float(settings.PRICE_GLM_PER_CORE_MONTH))),
+                Annotation(key="golem_price_glm_ram_gb_month", value=str(float(settings.PRICE_GLM_PER_GB_RAM_MONTH))),
+                Annotation(key="golem_price_glm_storage_gb_month", value=str(float(settings.PRICE_GLM_PER_GB_STORAGE_MONTH))),
             ]
+            # Numeric annotations: strictly integers
             numeric_annotations = [
                 Annotation(key="golem_cpu", value=resources["cpu"]),
                 Annotation(key="golem_memory", value=resources["memory"]),
                 Annotation(key="golem_storage", value=resources["storage"]),
-                Annotation(key="golem_price_usd_core_month", value=float(settings.PRICE_USD_PER_CORE_MONTH)),
-                Annotation(key="golem_price_usd_ram_gb_month", value=float(settings.PRICE_USD_PER_GB_RAM_MONTH)),
-                Annotation(key="golem_price_usd_storage_gb_month", value=float(settings.PRICE_USD_PER_GB_STORAGE_MONTH)),
-                Annotation(key="golem_price_glm_core_month", value=float(settings.PRICE_GLM_PER_CORE_MONTH)),
-                Annotation(key="golem_price_glm_ram_gb_month", value=float(settings.PRICE_GLM_PER_GB_RAM_MONTH)),
-                Annotation(key="golem_price_glm_storage_gb_month", value=float(settings.PRICE_GLM_PER_GB_STORAGE_MONTH)),
             ]
 
             if len(existing_keys) > 1:

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."),

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