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

{golem_vm_provider-0.1.37.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.37
+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.37.dist-info → golem_vm_provider-0.1.39.dist-info}/RECORD

@@ -1,38 +1,43 @@
 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=GV-YRB9eUQXaZNFkYZRVwOSmD9BBBqtctcUw7cV8xsE,18722
-provider/container.py,sha256=u8A1FuG2targtBBqQlSiPW1yCTOm1tbrRQh8sIHstiM,2442
+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=2-khnnzaaftiV1QfJoILkzX-ipa3m1PxSdNd7gy7Y0A,5672
-provider/discovery/golem_base_advertiser.py,sha256=qXIiQ0nvn7ytb6LR9KaMNFwGSE2HTY4XtMlkkAG7pj4,6093
+provider/discovery/advertiser.py,sha256=o-LiDl1j0lXMUU0-zPe3qerjpoD2360EA60Y_V_VeBc,6571
+provider/discovery/golem_base_advertiser.py,sha256=_UgxsedmBvSRX919wCp4Wo-pZV5fncesXj1k2h3jkXY,6869
 provider/discovery/golem_base_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=qU_fa8znPDNk-fQZ6Z3x6HDTbopK6RgfC_D8rixqBmY,709
-provider/main.py,sha256=LvpJxkOS3dKLJu4Ef80jS9Umtm1vX7Pf0We68-uGp1A,6630
+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=Bc7jOemhqgz9adaWOFLbWum8HFY7fmf1Mmx50-Ygwuo,2389
+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
 provider/utils/port_display.py,sha256=u1HWQFA2kPbsM-TnsQfL6Hr4KmjIZWZfsjoxarHpbW0,11981
-provider/utils/retry.py,sha256=1p12vZZkfotRDnv56jDXWG4W7jgGuZfRSXcbZC_ytTI,2935
+provider/utils/pricing.py,sha256=e8obIH3yan8HsXJXoFvyh7eS1DtXJT5NZediPWhmJ0k,6113
+provider/utils/retry.py,sha256=GvBjpr0DpTOgw28M2hI0yt17dpYLRwrxUUqVxWHQPtM,3148
 provider/utils/setup.py,sha256=Z5dLuBQkb5vdoQsu1HJZwXmu9NWsiBYJ7Vq9-C-_tY8,2932
 provider/vm/__init__.py,sha256=LJL504QGbqZvBbMN3G9ixMgAwvOWAKW37zUm_EiaW9M,508
 provider/vm/cloud_init.py,sha256=E5dDH7dqStRcJNDfbarBBe83-c9N63W8B5ycIrHI8eU,4627
 provider/vm/models.py,sha256=hNeXgOnXWyeSiYt07Pdks0B20cDi_VC8jV-tCxULNng,6350
 provider/vm/multipass.py,sha256=rjO3GtuS4O_wXyYXSUiDGWYtQV2LpGxm6kITrA-ghBQ,617
-provider/vm/multipass_adapter.py,sha256=1s3PtiaRmRxqOQJU651pIgZW1kwnZtl-Tclkk341TLM,10104
+provider/vm/multipass_adapter.py,sha256=BUC9thQqzKVZqpSWMI9Nbx-YMz-8OeYFj2bAFzFAjg8,10621
 provider/vm/name_mapper.py,sha256=14nKfCjJ1WkXfC4vnCYIxNGQUwcl2vcxrJYUAz4fL40,4073
 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.37.dist-info/METADATA,sha256=7GEwvwqNmRygjl7RYSrja4Zlx8U9TJszd3XUvLAycF8,10943
-golem_vm_provider-0.1.37.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-golem_vm_provider-0.1.37.dist-info/entry_points.txt,sha256=iFUajRxfViYkFcPMPv2EIjYm-BLOp86LJj_IjCwwZUw,74
-golem_vm_provider-0.1.37.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

@@ -39,7 +39,8 @@ def ensure_config() -> None:
         print("Using default settings – run with --help to customize")
 
 
-ensure_config()
+if not os.environ.get("GOLEM_PROVIDER_SKIP_BOOTSTRAP") and not os.environ.get("PYTEST_CURRENT_TEST"):
+    ensure_config()
 
 
 class Settings(BaseSettings):
@@ -125,12 +126,53 @@ class Settings(BaseSettings):
     # Discovery Service Settings
     DISCOVERY_URL: str = "http://195.201.39.101:9001"
     ADVERTISER_TYPE: str = "golem_base"  # or "discovery_server"
+    # Deprecated: use platform-specific intervals below
     ADVERTISEMENT_INTERVAL: int = 240  # seconds
+    DISCOVERY_ADVERTISEMENT_INTERVAL: int = 240  # seconds
+    GOLEM_BASE_ADVERTISEMENT_INTERVAL: int = 3600  # seconds (on-chain cost, keep higher)
 
     # Golem Base Settings
     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"
@@ -274,6 +316,14 @@ class Settings(BaseSettings):
     # Rate Limiting
     RATE_LIMIT_PER_MINUTE: int = 100
 
+    # Retry/Timeout Settings (for long-running external calls)
+    RETRY_ATTEMPTS: int = 5
+    RETRY_DELAY_SECONDS: float = 2.0
+    RETRY_BACKOFF: float = 2.0
+    CREATE_VM_MAX_RETRIES: int = 15
+    CREATE_VM_RETRY_DELAY_SECONDS: float = 5.0
+    LAUNCH_TIMEOUT_SECONDS: int = 300
+
     # Multipass Settings
     MULTIPASS_BINARY_PATH: str = Field(
         default="",
@@ -467,6 +517,25 @@ class Settings(BaseSettings):
             logger.info(f"Using manually provided IP: {v}")
         return v
 
+    # Pricing Settings (configured in USD; auto-converted to GLM)
+    # Per-month prices per unit
+    PRICE_USD_PER_CORE_MONTH: float = Field(default=5.0, ge=0)
+    PRICE_USD_PER_GB_RAM_MONTH: float = Field(default=2.0, ge=0)
+    PRICE_USD_PER_GB_STORAGE_MONTH: float = Field(default=0.1, ge=0)
+
+    # Auto-updated GLM-denominated prices (derived from USD via CoinGecko)
+    PRICE_GLM_PER_CORE_MONTH: float = Field(default=0.0, ge=0)
+    PRICE_GLM_PER_GB_RAM_MONTH: float = Field(default=0.0, ge=0)
+    PRICE_GLM_PER_GB_STORAGE_MONTH: float = Field(default=0.0, ge=0)
+
+    # CoinGecko integration
+    COINGECKO_API_URL: str = "https://api.coingecko.com/api/v3"
+    COINGECKO_IDS: str = "golem,golem-network-tokens"  # try both, first wins
+    PRICING_UPDATE_ENABLED: bool = True
+    PRICING_UPDATE_MIN_DELTA_PERCENT: float = Field(default=1.0, ge=0.0)
+    PRICING_UPDATE_INTERVAL_DISCOVERY: int = 900    # 15 minutes
+    PRICING_UPDATE_INTERVAL_GOLEM_BASE: int = 14400 # 4 hours
+
     class Config:
         env_prefix = "GOLEM_PROVIDER_"
         case_sensitive = True

provider/container.py

@@ -6,6 +6,7 @@ from .config import settings
 from .discovery.resource_tracker import ResourceTracker
 from .discovery.golem_base_advertiser import GolemBaseAdvertiser
 from .discovery.advertiser import DiscoveryServerAdvertiser
+from .discovery.multi_advertiser import MultiAdvertiser
 from .discovery.service import AdvertisementService
 from .service import ProviderService
 from .vm.multipass_adapter import MultipassAdapter
@@ -13,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):
@@ -32,6 +36,10 @@ class Container(containers.DeclarativeContainer):
             DiscoveryServerAdvertiser,
             resource_tracker=resource_tracker,
         ),
+        both=providers.Singleton(
+            MultiAdvertiser,
+            resource_tracker=resource_tracker,
+        ),
     )
 
     advertisement_service = providers.Singleton(
@@ -44,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,
@@ -76,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/discovery/advertiser.py

@@ -65,7 +65,7 @@ class DiscoveryServerAdvertiser(Advertiser):
         try:
             while not self._stop_event.is_set():
                 await self.post_advertisement()
-                await asyncio.sleep(settings.ADVERTISEMENT_INTERVAL)
+                await asyncio.sleep(settings.DISCOVERY_ADVERTISEMENT_INTERVAL)
         finally:
             await self.stop()
 
@@ -76,7 +76,12 @@ class DiscoveryServerAdvertiser(Advertiser):
             await self.session.close()
             self.session = None
 
-    @async_retry(retries=5, delay=1.0, backoff=2.0, exceptions=(aiohttp.ClientError, asyncio.TimeoutError))
+    @async_retry(
+        retries=settings.RETRY_ATTEMPTS,
+        delay=settings.RETRY_DELAY_SECONDS,
+        backoff=settings.RETRY_BACKOFF,
+        exceptions=(aiohttp.ClientError, asyncio.TimeoutError),
+    )
     async def _check_discovery_health(self):
         """Check discovery service health with retries."""
         if not self.session:
@@ -86,7 +91,12 @@ class DiscoveryServerAdvertiser(Advertiser):
             if not response.ok:
                 raise Exception(f"Discovery service health check failed: {response.status}")
 
-    @async_retry(retries=3, delay=1.0, backoff=2.0, exceptions=(aiohttp.ClientError, asyncio.TimeoutError))
+    @async_retry(
+        retries=settings.RETRY_ATTEMPTS,
+        delay=settings.RETRY_DELAY_SECONDS,
+        backoff=settings.RETRY_BACKOFF,
+        exceptions=(aiohttp.ClientError, asyncio.TimeoutError),
+    )
     async def post_advertisement(self):
         """Post resource advertisement to discovery service."""
         if not self.session:
@@ -115,7 +125,15 @@ class DiscoveryServerAdvertiser(Advertiser):
                 json={
                     "ip_address": ip_address,
                     "country": settings.PROVIDER_COUNTRY,
-                    "resources": resources
+                    "resources": resources,
+                    "pricing": {
+                        "usd_per_core_month": settings.PRICE_USD_PER_CORE_MONTH,
+                        "usd_per_gb_ram_month": settings.PRICE_USD_PER_GB_RAM_MONTH,
+                        "usd_per_gb_storage_month": settings.PRICE_USD_PER_GB_STORAGE_MONTH,
+                        "glm_per_core_month": settings.PRICE_GLM_PER_CORE_MONTH,
+                        "glm_per_gb_ram_month": settings.PRICE_GLM_PER_GB_RAM_MONTH,
+                        "glm_per_gb_storage_month": settings.PRICE_GLM_PER_GB_STORAGE_MONTH,
+                    }
                 },
                 timeout=aiohttp.ClientTimeout(total=5)
             ) as response:
@@ -132,7 +150,12 @@ class DiscoveryServerAdvertiser(Advertiser):
             logger.error("Advertisement request timed out")
             raise
 
-    @async_retry(retries=3, delay=1.0, backoff=2.0, exceptions=(aiohttp.ClientError, asyncio.TimeoutError))
+    @async_retry(
+        retries=settings.RETRY_ATTEMPTS,
+        delay=settings.RETRY_DELAY_SECONDS,
+        backoff=settings.RETRY_BACKOFF,
+        exceptions=(aiohttp.ClientError, asyncio.TimeoutError),
+    )
     async def _get_public_ip(self) -> str:
         """Get public IP address with retries."""
         if not self.session:

provider/discovery/golem_base_advertiser.py

@@ -36,7 +36,7 @@ class GolemBaseAdvertiser(Advertiser):
         try:
             while not self._stop_event.is_set():
                 await self.post_advertisement()
-                await asyncio.sleep(settings.ADVERTISEMENT_INTERVAL)
+                await asyncio.sleep(settings.GOLEM_BASE_ADVERTISEMENT_INTERVAL)
         finally:
             await self.stop()
 
@@ -70,11 +70,18 @@ class GolemBaseAdvertiser(Advertiser):
                 Annotation(key="golem_ip_address", value=ip_address),
                 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"),
             ]
             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/discovery/multi_advertiser.py

@@ -0,0 +1,28 @@
+import asyncio
+from typing import Optional
+
+from .advertiser import Advertiser
+from .golem_base_advertiser import GolemBaseAdvertiser
+from .advertiser import DiscoveryServerAdvertiser
+from .resource_tracker import ResourceTracker
+
+
+class MultiAdvertiser(Advertiser):
+    """Advertise to both Golem Base and the Discovery Server."""
+
+    def __init__(self, resource_tracker: ResourceTracker):
+        self.golem = GolemBaseAdvertiser(resource_tracker)
+        self.discovery = DiscoveryServerAdvertiser(resource_tracker)
+
+    async def initialize(self):
+        await asyncio.gather(self.golem.initialize(), self.discovery.initialize())
+
+    async def start_loop(self):
+        await asyncio.gather(self.golem.start_loop(), self.discovery.start_loop())
+
+    async def stop(self):
+        await asyncio.gather(self.golem.stop(), self.discovery.stop())
+
+    async def post_advertisement(self):
+        await asyncio.gather(self.golem.post_advertisement(), self.discovery.post_advertisement())
+

provider/discovery/service.py

@@ -21,4 +21,11 @@ class AdvertisementService:
         if self._task:
             self._task.cancel()
             await self._task
-        await self.advertiser.stop()
+        await self.advertiser.stop()
+
+    async def trigger_update(self):
+        """Trigger an immediate advertisement update."""
+        try:
+            await self.advertiser.post_advertisement()
+        except Exception:
+            pass

provider/main.py

@@ -121,6 +121,8 @@ except ImportError:
     import importlib_metadata as metadata
 
 cli = typer.Typer()
+pricing_app = typer.Typer(help="Configure USD pricing; auto-converts to GLM.")
+cli.add_typer(pricing_app, name="pricing")
 
 def print_version(ctx: typer.Context, value: bool):
     if not value:
@@ -149,6 +151,64 @@ def dev(no_verify_port: bool = typer.Option(True, "--no-verify-port", help="Skip
     """Start the provider server in development mode."""
     run_server(dev_mode=True, no_verify_port=no_verify_port)
 
+def _env_path_for(dev_mode: Optional[bool]) -> str:
+    from pathlib import Path
+    env_file = ".env.dev" if dev_mode else ".env"
+    return str(Path(__file__).parent.parent / env_file)
+
+def _write_env_vars(path: str, updates: dict):
+    # Simple .env updater: preserves other lines, replaces/append updated keys
+    import re
+    import io
+    try:
+        with open(path, "r") as f:
+            lines = f.readlines()
+    except FileNotFoundError:
+        lines = []
+
+    kv = {**updates}
+    pattern = re.compile(r"^(?P<k>[A-Z0-9_]+)=.*$")
+    out = []
+    seen = set()
+    for line in lines:
+        m = pattern.match(line.strip())
+        if not m:
+            out.append(line)
+            continue
+        k = m.group("k")
+        if k in kv:
+            out.append(f"{k}={kv[k]}\n")
+            seen.add(k)
+        else:
+            out.append(line)
+    for k, v in kv.items():
+        if k not in seen:
+            out.append(f"{k}={v}\n")
+
+    with open(path, "w") as f:
+        f.writelines(out)
+
+def _print_pricing_examples(glm_usd):
+    from decimal import Decimal
+    from .utils.pricing import calculate_monthly_cost, calculate_monthly_cost_usd
+    from .vm.models import VMResources
+    examples = [
+        ("Small", VMResources(cpu=1, memory=1, storage=10)),
+        ("Medium", VMResources(cpu=2, memory=4, storage=20)),
+        ("Example 2c/2g/10g", VMResources(cpu=2, memory=2, storage=10)),
+    ]
+    # Maintain legacy header for tests while adding a clearer caption
+    print("\nExample monthly costs with current settings:")
+    print("(Estimated monthly earnings with your current pricing)")
+    for name, res in examples:
+        glm = calculate_monthly_cost(res)
+        usd = calculate_monthly_cost_usd(res, glm_usd)
+        usd_str = f"${usd:.2f}" if usd is not None else "—"
+        glm_str = f"{glm:.4f} GLM"
+        print(
+            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):
     """Helper to run the uvicorn server."""
     import sys
@@ -209,3 +269,74 @@ def run_server(dev_mode: bool, no_verify_port: bool):
 
 if __name__ == "__main__":
     cli()
+
+
+@pricing_app.command("show")
+def pricing_show():
+    """Show current USD and GLM per-unit monthly prices and examples."""
+    from decimal import Decimal
+    from .utils.pricing import fetch_glm_usd_price, update_glm_unit_prices_from_usd
+
+    print("Current pricing (per month):")
+    print(
+        f"  - USD per unit: CPU ${settings.PRICE_USD_PER_CORE_MONTH}/core, RAM ${settings.PRICE_USD_PER_GB_RAM_MONTH}/GB, Disk ${settings.PRICE_USD_PER_GB_STORAGE_MONTH}/GB"
+    )
+    glm_usd = fetch_glm_usd_price()
+    if not glm_usd:
+        print("Error: Could not fetch GLM/USD price. Please try again later.")
+        raise typer.Exit(code=1)
+    # Coerce to Decimal for calculations if needed
+    from decimal import Decimal
+    if not isinstance(glm_usd, Decimal):
+        glm_usd = Decimal(str(glm_usd))
+    update_glm_unit_prices_from_usd(glm_usd)
+    print(f"  - GLM price: ${glm_usd} per GLM")
+    print(f"  - Rate: {glm_usd} USD/GLM")
+    print(
+        f"  - GLM per unit: CPU {round(float(settings.PRICE_GLM_PER_CORE_MONTH), 6)} GLM/core, RAM {round(float(settings.PRICE_GLM_PER_GB_RAM_MONTH), 6)} GLM/GB, Disk {round(float(settings.PRICE_GLM_PER_GB_STORAGE_MONTH), 6)} GLM/GB"
+    )
+    _print_pricing_examples(glm_usd)
+
+
+@pricing_app.command("set")
+def pricing_set(
+    usd_per_core: float = typer.Option(
+        ..., "--usd-per-core", "--core-usd", help="USD per CPU core per month"
+    ),
+    usd_per_mem: float = typer.Option(
+        ..., "--usd-per-mem", "--ram-usd", help="USD per GB of RAM per month"
+    ),
+    usd_per_disk: float = typer.Option(
+        ..., "--usd-per-disk", "--usd-per-storage", "--storage-usd", help="USD per GB of disk per month"
+    ),
+    dev: bool = typer.Option(False, "--dev", help="Write to .env.dev instead of .env"),
+):
+    """Set USD pricing; GLM rates auto-update via CoinGecko in background."""
+    if usd_per_core < 0 or usd_per_mem < 0 or usd_per_disk < 0:
+        raise typer.BadParameter("All pricing values must be >= 0")
+    env_path = _env_path_for(dev)
+    updates = {
+        "GOLEM_PROVIDER_PRICE_USD_PER_CORE_MONTH": usd_per_core,
+        "GOLEM_PROVIDER_PRICE_USD_PER_GB_RAM_MONTH": usd_per_mem,
+        "GOLEM_PROVIDER_PRICE_USD_PER_GB_STORAGE_MONTH": usd_per_disk,
+    }
+    _write_env_vars(env_path, updates)
+    print(f"Updated pricing in {env_path}")
+    # Immediately reflect in current process settings as well
+    settings.PRICE_USD_PER_CORE_MONTH = usd_per_core
+    settings.PRICE_USD_PER_GB_RAM_MONTH = usd_per_mem
+    settings.PRICE_USD_PER_GB_STORAGE_MONTH = usd_per_disk
+
+    from .utils.pricing import fetch_glm_usd_price, update_glm_unit_prices_from_usd
+    glm_usd = fetch_glm_usd_price()
+    if glm_usd:
+        # Coerce to Decimal for calculations if needed
+        from decimal import Decimal
+        if not isinstance(glm_usd, Decimal):
+            glm_usd = Decimal(str(glm_usd))
+        update_glm_unit_prices_from_usd(glm_usd)
+        print("Recalculated GLM prices due to updated USD configuration.")
+        _print_pricing_examples(glm_usd)
+    else:
+        print("Warning: could not fetch GLM/USD; GLM unit prices not recalculated.")
+        print("Tip: run 'golem-provider pricing show' when online to verify pricing with USD examples.")

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

@@ -4,6 +4,7 @@ from fastapi import FastAPI
 from .utils.logging import setup_logger
 from .vm.service import VMService
 from .discovery.service import AdvertisementService
+from .utils.pricing import PricingAutoUpdater
 
 logger = setup_logger(__name__)
 
@@ -15,6 +16,8 @@ class ProviderService:
         self.vm_service = vm_service
         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."""
@@ -35,6 +38,18 @@ class ProviderService:
             await self.port_manager.initialize()
             await self.vm_service.provider.initialize()
             await self.advertisement_service.start()
+            # Start pricing auto-updater; trigger re-advertise after updates
+            async def _on_price_updated(platform: str, glm_usd):
+                await self.advertisement_service.trigger_update()
+            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(
@@ -55,6 +70,10 @@ class ProviderService:
         logger.process("🔄 Cleaning up provider...")
         await self.advertisement_service.stop()
         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/utils/pricing.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal, ROUND_HALF_UP, getcontext
+from typing import Optional, Tuple
+import time
+import requests
+
+from ..vm.models import VMResources
+from ..config import settings
+from .logging import setup_logger
+
+logger = setup_logger(__name__)
+
+# Increase precision for financial calcs
+getcontext().prec = 28
+
+
+def quantize_money(value: Decimal) -> Decimal:
+    return value.quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
+
+
+def _coingecko_simple_price(ids: str) -> Optional[Decimal]:
+    base = settings.COINGECKO_API_URL.rstrip("/")
+    url = f"{base}/simple/price"
+    try:
+        resp = requests.get(url, params={"ids": ids, "vs_currencies": "usd"}, timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+        # Try ids in order and return the first available
+        for _id in ids.split(","):
+            _id = _id.strip()
+            if _id and _id in data and "usd" in data[_id]:
+                usd = Decimal(str(data[_id]["usd"]))
+                if usd > 0:
+                    return usd
+    except Exception as e:
+        logger.warning(f"CoinGecko price fetch failed: {e}")
+    return None
+
+
+def fetch_glm_usd_price() -> Optional[Decimal]:
+    """Fetch the current GLM price in USD from CoinGecko.
+
+    Tries multiple IDs to hedge against slug changes.
+    """
+    return _coingecko_simple_price(settings.COINGECKO_IDS)
+
+
+def usd_to_glm(usd_amount: Decimal, glm_usd: Decimal) -> Decimal:
+    if glm_usd <= 0:
+        raise ValueError("Invalid GLM/USD price")
+    return (usd_amount / glm_usd).quantize(Decimal("0.00000001"), rounding=ROUND_HALF_UP)
+
+
+def glm_to_usd(glm_amount: Decimal, glm_usd: Decimal) -> Decimal:
+    return (glm_amount * glm_usd).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
+
+
+def calculate_monthly_cost(resources: VMResources) -> Decimal:
+    """Calculate monthly cost in GLM for the given resources.
+
+    Uses the GLM-denominated price-per-unit values configured in settings.
+    """
+    core_price = Decimal(str(settings.PRICE_GLM_PER_CORE_MONTH))
+    ram_price = Decimal(str(settings.PRICE_GLM_PER_GB_RAM_MONTH))
+    storage_price = Decimal(str(settings.PRICE_GLM_PER_GB_STORAGE_MONTH))
+
+    total = (
+        core_price * Decimal(resources.cpu) +
+        ram_price * Decimal(resources.memory) +
+        storage_price * Decimal(resources.storage)
+    )
+    return total.quantize(Decimal("0.00000001"), rounding=ROUND_HALF_UP)
+
+
+# Note: function to derive per-unit prices from a total was intentionally not added.
+
+
+def calculate_monthly_cost_usd(resources: VMResources, glm_usd: Decimal) -> Optional[Decimal]:
+    cost_glm = calculate_monthly_cost(resources)
+    try:
+        return glm_to_usd(cost_glm, glm_usd)
+    except Exception:
+        return None
+
+
+def update_glm_unit_prices_from_usd(glm_usd: Decimal) -> Tuple[Decimal, Decimal, Decimal]:
+    """Recompute GLM per-unit monthly prices using current USD config and a GLM/USD rate.
+
+    Returns a tuple of (core_glm, ram_glm, storage_glm).
+    """
+    core_usd = Decimal(str(settings.PRICE_USD_PER_CORE_MONTH))
+    ram_usd = Decimal(str(settings.PRICE_USD_PER_GB_RAM_MONTH))
+    storage_usd = Decimal(str(settings.PRICE_USD_PER_GB_STORAGE_MONTH))
+
+    core_glm = usd_to_glm(core_usd, glm_usd)
+    ram_glm = usd_to_glm(ram_usd, glm_usd)
+    storage_glm = usd_to_glm(storage_usd, glm_usd)
+
+    # Persist on settings instance (in-memory)
+    settings.PRICE_GLM_PER_CORE_MONTH = float(core_glm)
+    settings.PRICE_GLM_PER_GB_RAM_MONTH = float(ram_glm)
+    settings.PRICE_GLM_PER_GB_STORAGE_MONTH = float(storage_glm)
+
+    logger.info(
+        f"Updated GLM prices from USD @ {glm_usd} USD/GLM: core={core_glm}, ram={ram_glm}, storage={storage_glm}"
+    )
+    return core_glm, ram_glm, storage_glm
+
+
+class PricingAutoUpdater:
+    """Background updater for pricing based on CoinGecko.
+
+    It refreshes GLM-per-unit prices from USD config and can trigger callbacks (e.g., re-advertise).
+    """
+
+    def __init__(self, on_updated_callback=None):
+        self._stop = False
+        self._on_updated = on_updated_callback
+        self._last_price: Optional[Decimal] = None
+
+    async def start(self):
+        if not settings.PRICING_UPDATE_ENABLED:
+            return
+
+        # Choose update interval based on platform to avoid excessive on-chain updates
+        interval = (
+            settings.PRICING_UPDATE_INTERVAL_GOLEM_BASE
+            if getattr(settings, "ADVERTISER_TYPE", "discovery_server") == "golem_base"
+            else settings.PRICING_UPDATE_INTERVAL_DISCOVERY
+        )
+        await self._run_loop(interval)
+
+    def stop(self):
+        self._stop = True
+
+    async def _run_loop(self, interval_discovery: int):
+        import asyncio
+
+        while not self._stop:
+            try:
+                glm_usd = fetch_glm_usd_price()
+                if glm_usd:
+                    changed = self._should_update(glm_usd)
+                    if changed:
+                        update_glm_unit_prices_from_usd(glm_usd)
+                        if callable(self._on_updated):
+                            # Inform callback which advertising platform is active
+                            platform = getattr(settings, "ADVERTISER_TYPE", "discovery_server")
+                            await self._on_updated(platform=platform, glm_usd=glm_usd)
+                else:
+                    logger.warning("Skipping pricing update; failed to fetch GLM price")
+            except Exception as e:
+                logger.error(f"Pricing update error: {e}")
+
+            await asyncio.sleep(interval_discovery)
+
+    def _should_update(self, new_price: Decimal) -> bool:
+        if self._last_price is None:
+            self._last_price = new_price
+            return True
+        old = self._last_price
+        if old == 0:
+            self._last_price = new_price
+            return True
+        delta = abs((new_price - old) / old) * Decimal("100")
+        if delta >= Decimal(str(settings.PRICING_UPDATE_MIN_DELTA_PERCENT)):
+            self._last_price = new_price
+            return True
+        return False

provider/utils/retry.py

@@ -7,6 +7,11 @@ logger = logging.getLogger(__name__)
 
 T = TypeVar('T')
 
+
+class NonRetryableError(Exception):
+    """Base class for errors that should not be retried by retry decorators."""
+    pass
+
 def async_retry(
     retries: int = 3,
     delay: float = 1.0,
@@ -68,7 +73,8 @@ def async_retry_unless_not_found(
                 try:
                     return await func(*args, **kwargs)
                 except exceptions as e:
-                    if isinstance(e, VMNotFoundError):
+                    # Skip retries for known non-retryable cases
+                    if isinstance(e, (VMNotFoundError, NonRetryableError)):
                         raise e
 
                     last_exception = e

provider/vm/multipass_adapter.py

@@ -4,7 +4,7 @@ import subprocess
 from pathlib import Path
 import asyncio
 from typing import Dict, List, Optional
-from ..utils.retry import async_retry_unless_not_found
+from ..utils.retry import async_retry_unless_not_found, NonRetryableError
 
 from ..config import settings
 from ..utils.logging import setup_logger
@@ -19,6 +19,11 @@ class MultipassError(VMError):
     pass
 
 
+class NonRetryableMultipassError(MultipassError, NonRetryableError):
+    """Multipass error that should not be retried (e.g., parse/validation errors)."""
+    pass
+
+
 class MultipassAdapter(VMProvider):
     """Manages VMs using Multipass."""
 
@@ -35,7 +40,7 @@ class MultipassAdapter(VMProvider):
 
         # We add a timeout to the launch command to prevent it from hanging indefinitely
         # e.g. during image download. 300 seconds = 5 minutes.
-        timeout = 300 if args[0] == 'launch' else None
+        timeout = settings.LAUNCH_TIMEOUT_SECONDS if args[0] == 'launch' else None
 
         try:
             return await asyncio.to_thread(
@@ -53,7 +58,11 @@ class MultipassAdapter(VMProvider):
             stderr = e.stderr if should_capture and e.stderr else "No stderr captured. See provider logs for command output."
             raise MultipassError(f"Multipass command '{' '.join(args)}' timed out after {timeout} seconds. Stderr: {stderr}")
 
-    @async_retry_unless_not_found(retries=5, delay=2.0)
+    @async_retry_unless_not_found(
+        retries=settings.RETRY_ATTEMPTS,
+        delay=settings.RETRY_DELAY_SECONDS,
+        backoff=settings.RETRY_BACKOFF,
+    )
     async def _get_vm_info(self, vm_id: str) -> Dict:
         """Get detailed information about a VM."""
         try:
@@ -70,7 +79,10 @@ class MultipassAdapter(VMProvider):
                 raise VMNotFoundError(f"VM {vm_id} not found in multipass") from e
             raise
         except (json.JSONDecodeError, KeyError) as e:
-            raise MultipassError(f"Failed to parse VM info or essential fields are missing: {e}")
+            # Parsing/validation issues are not transient; do not waste time retrying
+            raise NonRetryableMultipassError(
+                f"Failed to parse VM info or essential fields are missing: {e}"
+            )
 
     async def initialize(self) -> None:
         """Initialize the VM provider."""
@@ -100,8 +112,8 @@ class MultipassAdapter(VMProvider):
             logger.info(f"VM {multipass_name} launched, waiting for it to be ready...")
 
             ip_address = None
-            max_retries = 15
-            retry_delay = 5  # seconds
+            max_retries = settings.CREATE_VM_MAX_RETRIES
+            retry_delay = settings.CREATE_VM_RETRY_DELAY_SECONDS  # seconds
             for attempt in range(max_retries):
                 try:
                     info = await self._get_vm_info(multipass_name)
@@ -218,4 +230,4 @@ class MultipassAdapter(VMProvider):
 
     async def cleanup(self) -> None:
         """Cleanup resources used by the provider."""
-        pass
+        pass

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