golem-vm-provider 0.1.37__tar.gz → 0.1.39__tar.gz

{golem_vm_provider-0.1.37 → golem_vm_provider-0.1.39}/PKG-INFO

@@ -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 → golem_vm_provider-0.1.39}/README.md

@@ -187,6 +187,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
@@ -202,7 +225,8 @@ Request:
     "name": "my-webserver",
     "cpu_cores": 2,
     "memory_gb": 4,
-    "storage_gb": 20
+    "storage_gb": 20,
+    "stream_id": 123            // required when STREAM_PAYMENT_ADDRESS is set
 }
 ```
 
@@ -230,6 +254,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 → golem_vm_provider-0.1.39}/provider/api/models.py

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

{golem_vm_provider-0.1.37 → golem_vm_provider-0.1.39}/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"],
+    )

{golem_vm_provider-0.1.37 → golem_vm_provider-0.1.39}/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

{golem_vm_provider-0.1.37 → golem_vm_provider-0.1.39}/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,

{golem_vm_provider-0.1.37 → golem_vm_provider-0.1.39}/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:

{golem_vm_provider-0.1.37 → golem_vm_provider-0.1.39}/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:

golem_vm_provider-0.1.39/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())
+

{golem_vm_provider-0.1.37 → golem_vm_provider-0.1.39}/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

{golem_vm_provider-0.1.37 → golem_vm_provider-0.1.39}/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.")