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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.38
+Version: 0.1.39
 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
@@ -230,6 +230,29 @@ GOLEM_PROVIDER_DISCOVERY_URL="http://discovery.golem.network:9001"
 GOLEM_PROVIDER_ADVERTISEMENT_INTERVAL=240
 ```
 
+### Streaming Payments (Polygon GLM)
+
+Enable on‑chain stream‑gated rentals by configuring the following (env prefix `GOLEM_PROVIDER_`):
+
+- `POLYGON_RPC_URL` — Polygon PoS RPC URL (e.g., https://polygon-rpc.com)
+- `STREAM_PAYMENT_ADDRESS` — StreamPayment contract address; if non‑zero, VM creation requires a valid `stream_id`
+- `GLM_TOKEN_ADDRESS` — GLM ERC20 address (for info endpoint)
+
+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)
+
+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 +268,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 +297,24 @@ 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": "0xGLM"
+}
+```
+
+Use this endpoint to discover the correct recipient for creating a GLM stream.
  
  ## Operations
  

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

@@ -1,9 +1,9 @@
 provider/__init__.py,sha256=HO1fkPpZqPO3z8O8-eVIyx8xXSMIVuTR_b1YF0RtXOg,45
 provider/api/__init__.py,sha256=ssX1ugDqEPt8Fn04IymgmG-Ev8PiXLsCSaiZVvHQnec,344
-provider/api/models.py,sha256=hTQYzVZHJ-SD_pIpoV0KbPUghR-PUY9YKyUlETstwuQ,3567
-provider/api/routes.py,sha256=ZNXRunNYTu9CC1XcknOx3gHQMDEyXtVMC3fArXPJkt0,6434
-provider/config.py,sha256=gURUkVFATFiwZ3vboO0jPYUF7PqKDybLBm4Zr4OF14c,20294
-provider/container.py,sha256=0FYoZf8GVArJ7MbGXHZmnMucKAmVhF7ZcCt5_5qGiYE,2619
+provider/api/models.py,sha256=_y3N9amTFaHfH7_3uZlvhPAoUA4HY-93f-BBuC4EoBM,3830
+provider/api/routes.py,sha256=YCAJT9Cw4H5phbgsbYwppcn8H_3G1ogom6mdaPM-tHs,7683
+provider/config.py,sha256=98gBZiBdzzF5AuPvEiv4N79mgf0G2zZeld2_kMJ-DKA,21673
+provider/container.py,sha256=81x5LiA-qjYN1Uh_JdOxqvuIXiNDr9X3OXNN0VqYFCI,3681
 provider/discovery/__init__.py,sha256=Y6o8RxGevBpuQS3k32y-zSVbP6HBXG3veBl9ElVPKaU,349
 provider/discovery/advertiser.py,sha256=o-LiDl1j0lXMUU0-zPe3qerjpoD2360EA60Y_V_VeBc,6571
 provider/discovery/golem_base_advertiser.py,sha256=_UgxsedmBvSRX919wCp4Wo-pZV5fncesXj1k2h3jkXY,6869
@@ -14,9 +14,12 @@ provider/discovery/resource_tracker.py,sha256=MP7IXd3aIMsjB4xz5Oj9zFDTEnvrnw-Cyx
 provider/discovery/service.py,sha256=vX_mVSxvn3arnb2cKDM_SeJp1ZgPdImP2aUubeXgdRg,915
 provider/main.py,sha256=V1n7IFhV0Y2WMjD1_IomEYptdRu1G-K6U0JL8ip8Th8,11962
 provider/network/port_verifier.py,sha256=3l6WNwBHydggJRFYkAsuBp1eCxaU619kjWuM-zSVj2o,13267
+provider/payments/blockchain_service.py,sha256=0iHfvviQMSFfRSSqK0Y4gdbqPa0mrxtJIN4nSG9D0D0,5171
+provider/payments/monitor.py,sha256=kEuD_-amaNJY6Hkrx5hvWPqNtaslnruq3_EynB4bdUY,2804
+provider/payments/stream_map.py,sha256=qk6Y8hS72DplAifZ0ZMWPHBAyc_3IWIQyWUBuCU3_To,1191
 provider/security/ethereum.py,sha256=EwPZj4JR8OEpto6LhKjuuT3Z9pBX6P7-UQaqJtqFkYQ,1242
 provider/security/faucet.py,sha256=O2DgP3bIrRUm9tdLCdgnda9em0rPyeW42sWhO1EQJaA,5363
-provider/service.py,sha256=6Yv46SZu-25vN_SbzlymijZ-v37yY5t1wTqh6QlXhRM,2939
+provider/service.py,sha256=IIjeSM9T4r616nBRnxCUum_sgbyRusMMcja3yQd8zQI,3383
 provider/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 provider/utils/ascii_art.py,sha256=ykBFsztk57GIiz1NJ-EII5UvN74iECqQL4h9VmiW6Z8,3161
 provider/utils/logging.py,sha256=VV3oTYSRT8hUejtXLuua1M6kCHmIJgPspIkzsUVhYW0,1920
@@ -33,8 +36,8 @@ provider/vm/name_mapper.py,sha256=14nKfCjJ1WkXfC4vnCYIxNGQUwcl2vcxrJYUAz4fL40,40
 provider/vm/port_manager.py,sha256=iYSwjTjD_ziOhG8aI7juKHw1OwwRUTJQyQoRUNQvz9w,12514
 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=7MjJM4l3wylcBlOuADEVab6R5HfT5HInOFZuEGcoV3I,3982
-golem_vm_provider-0.1.38.dist-info/METADATA,sha256=1ritYsJarEhy6ghti1N4Sz7Q1mV61YxftPv7b3PFP8A,10943
-golem_vm_provider-0.1.38.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-golem_vm_provider-0.1.38.dist-info/entry_points.txt,sha256=iFUajRxfViYkFcPMPv2EIjYm-BLOp86LJj_IjCwwZUw,74
-golem_vm_provider-0.1.38.dist-info/RECORD,,
+provider/vm/service.py,sha256=Ki4SGNIZUq3XmaPMwAOoNzdZzKQsmFXid374wgjFPes,4636
+golem_vm_provider-0.1.39.dist-info/METADATA,sha256=GiVapYP4oE2as0468l_t3Fp12Y_s_mOR1a9UlDsrETY,12580
+golem_vm_provider-0.1.39.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.39.dist-info/entry_points.txt,sha256=iFUajRxfViYkFcPMPv2EIjYm-BLOp86LJj_IjCwwZUw,74
+golem_vm_provider-0.1.39.dist-info/RECORD,,

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

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
 
@@ -31,6 +32,15 @@ async def create_vm(
         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(
@@ -46,6 +56,9 @@ async def create_vm(
     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")
@@ -168,3 +181,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"],
+    )

provider/config.py

@@ -135,6 +135,44 @@ 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://polygon-rpc.com",
+        description="Polygon PoS RPC URL for GLM payments"
+    )
+    STREAM_PAYMENT_ADDRESS: str = Field(
+        default="0x0000000000000000000000000000000000000000",
+        description="Deployed StreamPayment contract address"
+    )
+    GLM_TOKEN_ADDRESS: str = Field(
+        default="0x0000000000000000000000000000000000000000",
+        description="GLM ERC20 token address on target network"
+    )
+    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"
+    )
+
     # VM Settings
     MAX_VMS: int = 10
     DEFAULT_VM_IMAGE: str = "ubuntu:24.04"

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,

provider/payments/blockchain_service.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from web3 import Web3
+from eth_account import Account
+
+
+STREAM_PAYMENT_ABI = [
+    {
+        "inputs": [
+            {"internalType": "address", "name": "token", "type": "address"},
+            {"internalType": "address", "name": "recipient", "type": "address"},
+            {"internalType": "uint256", "name": "deposit", "type": "uint256"},
+            {"internalType": "uint128", "name": "ratePerSecond", "type": "uint128"},
+        ],
+        "name": "createStream",
+        "outputs": [{"internalType": "uint256", "name": "streamId", "type": "uint256"}],
+        "stateMutability": "nonpayable",
+        "type": "function",
+    },
+    {
+        "inputs": [{"internalType": "uint256", "name": "streamId", "type": "uint256"}],
+        "name": "withdraw",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+    },
+    {
+        "inputs": [{"internalType": "uint256", "name": "streamId", "type": "uint256"}],
+        "name": "terminate",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+    },
+    {
+        "inputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
+        "name": "streams",
+        "outputs": [
+            {"internalType": "address", "name": "token", "type": "address"},
+            {"internalType": "address", "name": "sender", "type": "address"},
+            {"internalType": "address", "name": "recipient", "type": "address"},
+            {"internalType": "uint128", "name": "startTime", "type": "uint128"},
+            {"internalType": "uint128", "name": "stopTime", "type": "uint128"},
+            {"internalType": "uint128", "name": "ratePerSecond", "type": "uint128"},
+            {"internalType": "uint256", "name": "deposit", "type": "uint256"},
+            {"internalType": "uint256", "name": "withdrawn", "type": "uint256"},
+            {"internalType": "bool", "name": "halted", "type": "bool"}
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+]
+
+
+@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"]
+
+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"
+
+    def terminate(self, stream_id: int) -> str:
+        fn = self.contract.functions.terminate(int(stream_id))
+        receipt = self._send(fn)
+        return receipt["transactionHash"]

provider/payments/monitor.py

@@ -0,0 +1,64 @@
+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)
+                        if withdrawable >= self.settings.STREAM_MIN_WITHDRAW_WEI:
+                            try:
+                                self.client.withdraw(stream_id)
+                            except Exception as e:
+                                logger.warning(f"withdraw failed for {stream_id}: {e}")
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"stream monitor error: {e}")
+

provider/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)
+

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):

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()