request-vm-on-golem 0.1.39__py3-none-any.whl → 0.1.41__py3-none-any.whl

{request_vm_on_golem-0.1.39.dist-info → request_vm_on_golem-0.1.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: request-vm-on-golem
-Version: 0.1.39
+Version: 0.1.41
 Summary: VM on Golem Requestor CLI - Create and manage virtual machines on the Golem Network
 Keywords: golem,vm,cloud,decentralized,cli
 Author: Phillip Jensen
@@ -119,6 +119,64 @@ The SSH connection process:
 2. The provider's proxy system forwards your SSH connection to the VM
 3. All traffic is securely routed through the allocated port
 
+## Streaming Payments (Polygon GLM)
+
+This requestor integrates with an on‑chain StreamPayment contract to enable “pay‑as‑you‑go” rentals.
+
+Flow:
+
+1. Fetch provider info:
+   - `GET http://{provider}:7466/api/v1/provider/info` → `provider_id`, `stream_payment_address`, `glm_token_address`.
+2. Compute `ratePerSecond` from provider pricing and requested VM resources.
+3. Ensure `deposit >= ratePerSecond * 3600` (≥ 1 hour runway recommended/minimum).
+4. Create a stream (approve + `createStream(GLM, provider_id, deposit, ratePerSecond)`), capture `stream_id`.
+5. Create VM: `POST /api/v1/vms` with `stream_id` included.
+6. Top‑up over time with `topUp(stream_id, amount)` to extend stopTime and keep the VM running indefinitely.
+7. On stop/destroy: the requestor will best‑effort `withdraw` / `terminate` to settle.
+
+CLI helpers
+
+- Open a stream for a planned VM (computes rate from provider pricing):
+
+```bash
+poetry run golem vm stream open \
+  --provider-id 0xProvider \
+  --cpu 2 --memory 4 --storage 20 \
+  --hours 1
+# prints { stream_id, rate_per_second_wei, deposit_wei }
+```
+
+- Top up an existing stream:
+
+```bash
+# Add 3 hours at prior rate
+poetry run golem vm stream topup --stream-id 123 --hours 3
+
+# Or specify exact GLM amount
+poetry run golem vm stream topup --stream-id 123 --glm 25.0
+```
+
+- Create a VM and attach an existing stream:
+
+```bash
+poetry run golem vm create my-vm \
+  --provider-id 0xProvider \
+  --cpu 2 --memory 4 --storage 20 \
+  --stream-id 123
+```
+
+Environment (env prefix `GOLEM_REQUESTOR_`):
+
+- `polygon_rpc_url` — Polygon PoS RPC URL
+- `stream_payment_address` — StreamPayment address
+- `glm_token_address` — GLM ERC20 address
+- `provider_eth_address` — optional helper for development; in production always use `/provider/info`
+
+Efficiency tips:
+
+- Batch top‑ups (e.g., add several hours at once) to reduce on‑chain calls.
+- Withdrawals are typically executed by providers; requestors don’t need to withdraw.
+
 ## Installation
 
 ```bash
@@ -175,7 +233,7 @@ Example output:
 ────────────────────────────────────────────────
   🌍 Available Providers (3 total)
 ────────────────────────────────────────────────
-Provider ID     Country   CPU    Memory    Storage
+Provider ID     Country   CPU    Memory    Disk
 provider-1      🌍 SE     💻 4    🧠 8GB    💾 40GB
 provider-2      🌍 US     💻 8    🧠 16GB   💾 80GB
 provider-3      🌍 DE     💻 2    🧠 4GB    💾 20GB
@@ -206,7 +264,7 @@ Example output:
   VM Details
   ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
   🏷️  Name      : my-webserver
-  💻 Resources  : 2 CPU, 4GB RAM, 20GB Storage
+  💻 Resources  : 2 CPU, 4GB RAM, 20GB Disk
   🟢 Status     : running
 
   Connection Details

{request_vm_on_golem-0.1.39.dist-info → request_vm_on_golem-0.1.41.dist-info}/RECORD

@@ -1,24 +1,25 @@
 requestor/__init__.py,sha256=OqSUAh1uZBMx7GW0MoSMg967PVdmT8XdPJx3QYjwkak,116
 requestor/api/main.py,sha256=7utCzFNbh5Ol-vsBWeSwT4lXeHD7zdA-GFZuS3rHMWc,2180
 requestor/cli/__init__.py,sha256=e3E4oEGxmGj-STPtFkQwg_qIWhR0JAiAQdw3G1hXciU,37
-requestor/cli/commands.py,sha256=lQCjx6uJH0Gy1mtnByaOG1Szk3kER3Vc6ZpfJqUEcD8,27453
-requestor/config.py,sha256=O39E-Wa-ewqdC9XP5nvj3zkOs52mevvFMyQGtHaqANk,4668
+requestor/cli/commands.py,sha256=b9_Vy30rf3hpoBb_9Gu9z4mPWF3_oBjUjd-5pX2bVvU,33277
+requestor/config.py,sha256=suWN2-4AL0Pphu2t-_WiTKIFG-0_cJjWwR_CIOW1c24,5320
 requestor/db/__init__.py,sha256=Gm5DfWls6uvCZZ3HGGnyRHswbUQdeA5OGN8yPwH0hc8,88
 requestor/db/sqlite.py,sha256=l5pWbx2qlHuar1N_a0B9tVnmumLJY1w5rp3yZ7jmsC0,4146
 requestor/errors.py,sha256=wVpHBuYgQx5pTe_SamugfK-k768noikY1RxvPOjQGko,665
+requestor/payments/blockchain_service.py,sha256=w9ONdKVf2E7BCEgDRiTeEqwdNTr8SqZiXHKdV5JH2ZQ,5757
 requestor/provider/__init__.py,sha256=fmW23aYUVciF8-gmBZkG-PLhn22upmcDzdPfAOLHG6g,103
-requestor/provider/client.py,sha256=OUP7CoOCCtKD6DB9eqFkOXK6A2BLFdM4DWSkoulJQxg,3213
+requestor/provider/client.py,sha256=WXCm-1bytcgsuHEZzpg7RjjDOTuaXC9cj0Mrm7e6DSw,3676
 requestor/run.py,sha256=GqOG6n34szt8Sp3SEqjRV6huWm737yCN6YnBqoiwI-U,1785
 requestor/services/__init__.py,sha256=1qSn_6RMn0KB0A7LCnY2IW6_tC3HBQsdfkFeV-h94eM,172
 requestor/services/database_service.py,sha256=GlSrzzzd7PSYQJNup00sxkB-B2PMr1__04K8k5QSWvs,2996
-requestor/services/provider_service.py,sha256=iejw8Q-ziK3Ny0cEAD1EHejUsAqf9BwJTa7jFmei0_8,9773
+requestor/services/provider_service.py,sha256=auUc5XSHWbtOzyLHFqJ4RF337rCNYThzb7TjvUaK_uo,14542
 requestor/services/ssh_service.py,sha256=tcOCtk2SlB9Uuv-P2ghR22e7BJ9kigQh5b4zSGdPFns,4280
-requestor/services/vm_service.py,sha256=yHvGtfzoWw_wAC7MwgZEudbK8ElxB_2fCuG5Xa-F1KE,6820
+requestor/services/vm_service.py,sha256=UPPj7aD0b7nCyNH6I-b35xdsqAkRUiQlpQBVGK4B7ms,8858
 requestor/ssh/__init__.py,sha256=hNgSqJ5s1_AwwxVRyFjUqh_LTBpI4Hmzq0F-f_wXN9g,119
-requestor/ssh/manager.py,sha256=XhZjz7_BRPnmpu-zxqnGHLCq0b2JZ8Xr8zc1OlMNDkc,9355
+requestor/ssh/manager.py,sha256=3jQtbbK7CVC2yD1zCO88jGXh2fBcuv3CzWEqDLuaQVk,9758
 requestor/utils/logging.py,sha256=oFNpO8pJboYM8Wp7g3HOU4HFyBTKypVdY15lUiz1a4I,3721
 requestor/utils/spinner.py,sha256=PUHJdTD9jpUHur__01_qxXy87WFfNmjQbD_sLG-KlGo,2459
-request_vm_on_golem-0.1.39.dist-info/METADATA,sha256=O_wg13P3E6efitdI5Zxr2urcvky3RZEWpOfgzdzcWlg,9950
-request_vm_on_golem-0.1.39.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-request_vm_on_golem-0.1.39.dist-info/entry_points.txt,sha256=Z-skRNpJ8aZcIl_En9mEm1ygkp9FKy0bzQoL3zO52-0,44
-request_vm_on_golem-0.1.39.dist-info/RECORD,,
+request_vm_on_golem-0.1.41.dist-info/METADATA,sha256=znwTKJHh21R9DsDgeHeaKFwxZFFC95vOTj-kScsc2Tc,11924
+request_vm_on_golem-0.1.41.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+request_vm_on_golem-0.1.41.dist-info/entry_points.txt,sha256=Z-skRNpJ8aZcIl_En9mEm1ygkp9FKy0bzQoL3zO52-0,44
+request_vm_on_golem-0.1.41.dist-info/RECORD,,

requestor/cli/commands.py

@@ -90,7 +90,7 @@ def vm():
 @vm.command(name='providers')
 @click.option('--cpu', type=int, help='Minimum CPU cores required')
 @click.option('--memory', type=int, help='Minimum memory (GB) required')
-@click.option('--storage', type=int, help='Minimum storage (GB) required')
+@click.option('--storage', type=int, help='Minimum disk (GB) required')
 @click.option('--country', help='Preferred provider country')
 @click.option('--driver', type=click.Choice(['central', 'golem-base']), default=None, help='Discovery driver to use')
 @click.option('--json', 'as_json', is_flag=True, help='Output in JSON format')
@@ -106,7 +106,7 @@ async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Opt
             if memory:
                 logger.detail(f"Memory: {memory}GB+")
             if storage:
-                logger.detail(f"Storage: {storage}GB+")
+                logger.detail(f"Disk: {storage}GB+")
             if country:
                 logger.detail(f"Country: {country}")
 
@@ -117,6 +117,9 @@ async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Opt
         # Initialize provider service
         provider_service = ProviderService()
         async with provider_service:
+            # If a full spec is provided, enable per-provider estimate display
+            if cpu and memory and storage:
+                provider_service.estimate_spec = (cpu, memory, storage)
             providers = await provider_service.find_providers(
                 cpu=cpu,
                 memory=memory,
@@ -129,6 +132,12 @@ async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Opt
             logger.warning("No providers found matching criteria")
             return {"providers": []}
 
+        # If JSON requested and full spec provided, include estimates per provider
+        if as_json and cpu and memory and storage:
+            for p in providers:
+                est = provider_service.compute_estimate(p, (cpu, memory, storage))
+                if est is not None:
+                    p['estimate'] = est
         result = {"providers": providers}
 
         if as_json:
@@ -163,9 +172,11 @@ async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Opt
 @click.option('--provider-id', required=True, help='Provider ID to use')
 @click.option('--cpu', type=int, required=True, help='Number of CPU cores')
 @click.option('--memory', type=int, required=True, help='Memory in GB')
-@click.option('--storage', type=int, required=True, help='Storage in GB')
+@click.option('--storage', type=int, required=True, help='Disk in GB')
+@click.option('--stream-id', type=int, default=None, help='Optional StreamPayment stream id to fund this VM')
+@click.option('--yes', is_flag=True, help='Do not prompt for confirmation')
 @async_command
-async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage: int):
+async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage: int, stream_id: int | None, yes: bool):
     """Create a new VM on a specific provider."""
     try:
         # Show configuration details
@@ -173,7 +184,7 @@ async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage:
         click.echo(click.style("  VM Configuration", fg="blue", bold=True))
         click.echo("─" * 60)
         click.echo(f"  Provider   : {click.style(provider_id, fg='cyan')}")
-        click.echo(f"  Resources  : {click.style(f'{cpu} CPU, {memory}GB RAM, {storage}GB Storage', fg='cyan')}")
+        click.echo(f"  Resources  : {click.style(f'{cpu} CPU, {memory}GB RAM, {storage}GB Disk', fg='cyan')}")
         click.echo("─" * 60 + "\n")
 
         # Now start the deployment with spinner
@@ -191,6 +202,21 @@ async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage:
                 if not provider_ip and config.environment == "production":
                     raise RequestorError("Provider IP address not found in advertisement")
 
+                # Before proceeding, show estimated monthly price and confirm
+                provider_service.estimate_spec = (cpu, memory, storage)
+                est_row = await provider_service.format_provider_row(provider, colorize=False)
+                # Columns: ... [7]=USD/core/mo, [8]=USD/GB RAM/mo, [9]=USD/GB Disk/mo, [10]=Est. $/mo, [11]=Est. GLM/mo
+                est_usd = est_row[10]
+                est_glm = est_row[11]
+                price_str = f"~${est_usd}/mo" if est_usd != '—' else "(no USD pricing)"
+                if est_glm != '—':
+                    price_str += f" (~{est_glm} GLM/mo)"
+                click.echo(click.style(f"  💵 Estimated Monthly Cost: {price_str}", fg='yellow', bold=True))
+                if not yes:
+                    if not click.confirm("Proceed with VM creation?", default=True):
+                        logger.warning("Creation cancelled by user")
+                        return
+
                 # Setup SSH
                 ssh_service = SSHService(config.ssh_key_dir)
                 key_pair = await ssh_service.get_key_pair()
@@ -207,7 +233,8 @@ async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage:
                         memory=memory,
                         storage=storage,
                         provider_ip=provider_ip,
-                        ssh_key=key_pair.public_key_content
+                        ssh_key=key_pair.public_key_content,
+                        stream_id=stream_id
                     )
 
                     # Get access info from config
@@ -222,7 +249,7 @@ async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage:
         click.echo(click.style("  VM Details", fg="blue", bold=True))
         click.echo("  " + "┈" * 25)
         click.echo(f"  🏷️  Name      : {click.style(name, fg='cyan')}")
-        click.echo(f"  💻 Resources  : {click.style(f'{cpu} CPU, {memory}GB RAM, {storage}GB Storage', fg='cyan')}")
+        click.echo(f"  💻 Resources  : {click.style(f'{cpu} CPU, {memory}GB RAM, {storage}GB Disk', fg='cyan')}")
         click.echo(f"  🟢 Status     : {click.style('running', fg='green')}")
         
         # Connection Details Section
@@ -256,6 +283,88 @@ async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage:
         raise click.Abort()
 
 
+@vm.group(name='stream')
+def vm_stream():
+    """Streaming payments helpers"""
+    pass
+
+
+@vm_stream.command('open')
+@click.option('--provider-id', required=True, help='Provider ID to use')
+@click.option('--cpu', type=int, required=True, help='CPU cores for rate calc')
+@click.option('--memory', type=int, required=True, help='Memory (GB) for rate calc')
+@click.option('--storage', type=int, required=True, help='Storage (GB) for rate calc')
+@click.option('--hours', type=int, default=1, help='Deposit coverage in hours (default 1)')
+@async_command
+async def stream_open(provider_id: str, cpu: int, memory: int, storage: int, hours: int):
+    """Create a GLM stream for a planned VM rental."""
+    from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
+    try:
+        provider_service = ProviderService()
+        async with provider_service:
+            provider = await provider_service.verify_provider(provider_id)
+            est = provider_service.compute_estimate(provider, (cpu, memory, storage))
+            if not est or est.get('glm_per_month') is None:
+                raise RequestorError('Provider does not advertise GLM pricing; cannot compute ratePerSecond')
+            glm_month = est['glm_per_month']
+            glm_per_second = float(glm_month) / (730.0 * 3600.0)
+            rate_per_second_wei = int(glm_per_second * (10**18))
+
+            provider_ip = 'localhost' if config.environment == "development" else provider.get('ip_address')
+            if not provider_ip and config.environment == "production":
+                raise RequestorError("Provider IP address not found in advertisement")
+            provider_url = config.get_provider_url(provider_ip)
+            async with ProviderClient(provider_url) as client:
+                info = await client.get_provider_info()
+                recipient = info['provider_id']
+
+            deposit_wei = rate_per_second_wei * int(hours) * 3600
+            spc = StreamPaymentConfig(
+                rpc_url=config.polygon_rpc_url,
+                contract_address=config.stream_payment_address,
+                glm_token_address=config.glm_token_address,
+                private_key=config.ethereum_private_key,
+            )
+            sp = StreamPaymentClient(spc)
+            stream_id = sp.create_stream(recipient, deposit_wei, rate_per_second_wei)
+            click.echo(json.dumps({"stream_id": stream_id, "rate_per_second_wei": rate_per_second_wei, "deposit_wei": deposit_wei}, indent=2))
+    except Exception as e:
+        logger.error(f"Failed to open stream: {e}")
+        raise click.Abort()
+
+
+@vm_stream.command('topup')
+@click.option('--stream-id', type=int, required=True)
+@click.option('--glm', type=float, required=False, help='GLM amount to add')
+@click.option('--hours', type=int, required=False, help='Hours of coverage to add at prior rate')
+@async_command
+async def stream_topup(stream_id: int, glm: float | None, hours: int | None):
+    """Top up a stream. Provide either --glm or --hours (using prior rate)."""
+    from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
+    try:
+        spc = StreamPaymentConfig(
+            rpc_url=config.polygon_rpc_url,
+            contract_address=config.stream_payment_address,
+            glm_token_address=config.glm_token_address,
+            private_key=config.ethereum_private_key,
+        )
+        sp = StreamPaymentClient(spc)
+        add_wei: int
+        if glm is not None:
+            add_wei = int(float(glm) * (10**18))
+        elif hours is not None:
+            # naive: use last known rate by reading on-chain stream
+            rate = sp.contract.functions.streams(int(stream_id)).call()[5]  # ratePerSecond
+            add_wei = int(rate) * int(hours) * 3600
+        else:
+            raise RequestorError('Provide either --glm or --hours')
+        tx = sp.top_up(stream_id, add_wei)
+        click.echo(json.dumps({"stream_id": stream_id, "topped_up_wei": add_wei, "tx": tx}, indent=2))
+    except Exception as e:
+        logger.error(f"Failed to top up stream: {e}")
+        raise click.Abort()
+
+
 @vm.command(name='ssh')
 @click.argument('name')
 @async_command
@@ -341,7 +450,7 @@ async def info_vm(name: str, as_json: bool):
                 "SSH Port",
                 "CPU",
                 "Memory (GB)",
-                "Storage (GB)",
+                "Disk (GB)",
             ]
 
             row = [

requestor/config.py

@@ -94,6 +94,24 @@ class RequestorConfig(BaseSettings):
         description="Private key for Golem Base"
     )
     
+    # 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"
+    )
+    provider_eth_address: str = Field(
+        default="",
+        description="Optional provider Ethereum address for test/dev streaming"
+    )
+
     # Base Directory
     base_dir: Path = Field(
         default_factory=lambda: Path.home() / ".golem" / "requestor",

requestor/payments/blockchain_service.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, 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",
+    },
+    {
+        "anonymous": False,
+        "inputs": [
+            {"indexed": True, "internalType": "uint256", "name": "streamId", "type": "uint256"},
+            {"indexed": True, "internalType": "address", "name": "sender", "type": "address"},
+            {"indexed": True, "internalType": "address", "name": "recipient", "type": "address"},
+            {"indexed": False, "internalType": "address", "name": "token", "type": "address"},
+            {"indexed": False, "internalType": "uint256", "name": "deposit", "type": "uint256"},
+            {"indexed": False, "internalType": "uint256", "name": "ratePerSecond", "type": "uint256"},
+            {"indexed": False, "internalType": "uint256", "name": "startTime", "type": "uint256"},
+            {"indexed": False, "internalType": "uint256", "name": "stopTime", "type": "uint256"},
+        ],
+        "name": "StreamCreated",
+        "type": "event",
+    },
+]
+
+ERC20_ABI = [
+    {
+        "name": "approve",
+        "type": "function",
+        "stateMutability": "nonpayable",
+        "inputs": [
+            {"name": "spender", "type": "address"},
+            {"name": "amount", "type": "uint256"},
+        ],
+        "outputs": [{"name": "", "type": "bool"}],
+    }
+]
+
+
+@dataclass
+class StreamPaymentConfig:
+    rpc_url: str
+    contract_address: str
+    glm_token_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
+        )
+        self.erc20 = self.web3.eth.contract(
+            address=Web3.to_checksum_address(cfg.glm_token_address), abi=ERC20_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),
+            }
+        )
+        # In production, sign and send raw; in tests, Account may be a dummy without signer
+        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, "logs": receipt.logs}
+
+    def create_stream(self, provider_address: str, deposit_wei: int, rate_per_second_wei: int) -> int:
+        # 1) Approve deposit for the StreamPayment contract
+        approve = self.erc20.functions.approve(self.contract.address, int(deposit_wei))
+        self._send(approve)
+
+        # 2) Create stream
+        fn = self.contract.functions.createStream(
+            self.erc20.address,
+            Web3.to_checksum_address(provider_address),
+            int(deposit_wei),
+            int(rate_per_second_wei),
+        )
+        receipt = self._send(fn)
+
+        # Try to parse StreamCreated event for streamId
+        try:
+            for log in receipt["logs"]:
+                # very naive filter: topic0 = keccak256(StreamCreated(...))
+                # When ABI is attached to contract, use contract.events
+                ev = self.contract.events.StreamCreated().process_log(log)
+                return int(ev["args"]["streamId"])
+        except Exception:
+            pass
+        # As a fallback, cannot easily fetch return value from a tx; caller should query later
+        raise RuntimeError("create_stream: could not parse streamId from receipt")
+
+    def withdraw(self, stream_id: int) -> str:
+        fn = self.contract.functions.withdraw(int(stream_id))
+        receipt = self._send(fn)
+        return receipt["transactionHash"]
+
+    def terminate(self, stream_id: int) -> str:
+        fn = self.contract.functions.terminate(int(stream_id))
+        receipt = self._send(fn)
+        return receipt["transactionHash"]
+
+    def top_up(self, stream_id: int, amount_wei: int) -> str:
+        # Approve first
+        approve = self.erc20.functions.approve(self.contract.address, int(amount_wei))
+        self._send(approve)
+        # Top up
+        fn = self.contract.functions.topUp(int(stream_id), int(amount_wei))
+        receipt = self._send(fn)
+        return receipt["transactionHash"]

requestor/provider/client.py

@@ -21,26 +21,37 @@ class ProviderClient:
         cpu: int,
         memory: int,
         storage: int,
-        ssh_key: str
+        ssh_key: str,
+        stream_id: int | None = None,
     ) -> Dict:
         """Create a VM on the provider."""
+        payload = {
+            "name": name,
+            "resources": {
+                "cpu": cpu,
+                "memory": memory,
+                "storage": storage
+            },
+            "ssh_key": ssh_key
+        }
+        if stream_id is not None:
+            payload["stream_id"] = int(stream_id)
         async with self.session.post(
             f"{self.provider_url}/api/v1/vms",
-            json={
-                "name": name,
-                "resources": {
-                    "cpu": cpu,
-                    "memory": memory,
-                    "storage": storage
-                },
-                "ssh_key": ssh_key
-            }
+            json=payload
         ) as response:
             if not response.ok:
                 error_text = await response.text()
                 raise Exception(f"Failed to create VM: {error_text}")
             return await response.json()
 
+    async def get_provider_info(self) -> Dict:
+        async with self.session.get(f"{self.provider_url}/api/v1/provider/info") as response:
+            if not response.ok:
+                error_text = await response.text()
+                raise Exception(f"Failed to fetch provider info: {error_text}")
+            return await response.json()
+
     async def add_ssh_key(self, vm_id: str, key: str) -> None:
         """Add SSH key to VM."""
         async with self.session.post(

requestor/services/provider_service.py

@@ -15,6 +15,39 @@ class ProviderService:
     def __init__(self):
         self.session = None
         self.golem_base_client = None
+        # Optional spec (cpu, memory, storage) to compute estimates for display
+        self.estimate_spec: Optional[tuple[int, int, int]] = None
+
+    def compute_estimate(self, provider: Dict, spec: tuple[int, int, int]) -> Optional[Dict]:
+        """Compute estimated pricing for a given spec, if provider has pricing.
+
+        Returns dict with usd_per_month, glm_per_month (if GLM per-unit available),
+        and usd_per_hour, or None if insufficient pricing data.
+        """
+        pricing = provider.get('pricing') or {}
+        usd_core = pricing.get('usd_per_core_month')
+        usd_ram = pricing.get('usd_per_gb_ram_month')
+        usd_storage = pricing.get('usd_per_gb_storage_month')
+        if usd_core is None or usd_ram is None or usd_storage is None:
+            return None
+        cpu, mem, sto = spec
+        try:
+            usd_per_month = float(usd_core) * cpu + float(usd_ram) * mem + float(usd_storage) * sto
+            glm_core = pricing.get('glm_per_core_month')
+            glm_ram = pricing.get('glm_per_gb_ram_month')
+            glm_storage = pricing.get('glm_per_gb_storage_month')
+            glm_per_month = None
+            if glm_core is not None and glm_ram is not None and glm_storage is not None:
+                glm_per_month = float(glm_core) * cpu + float(glm_ram) * mem + float(glm_storage) * sto
+            usd_per_hour = usd_per_month / 730.0
+            # Round for display consistency
+            return {
+                'usd_per_month': round(usd_per_month, 4),
+                'usd_per_hour': round(usd_per_hour, 6),
+                'glm_per_month': round(glm_per_month, 8) if glm_per_month is not None else None,
+            }
+        except Exception:
+            return None
 
     async def __aenter__(self):
         self.session = aiohttp.ClientSession()
@@ -91,6 +124,14 @@ class ProviderService:
                         'memory': int(annotations.get('golem_memory', 0)),
                         'storage': int(annotations.get('golem_storage', 0)),
                     },
+                    'pricing': {
+                        'usd_per_core_month': annotations.get('golem_price_usd_core_month'),
+                        'usd_per_gb_ram_month': annotations.get('golem_price_usd_ram_gb_month'),
+                        'usd_per_gb_storage_month': annotations.get('golem_price_usd_storage_gb_month'),
+                        'glm_per_core_month': annotations.get('golem_price_glm_core_month'),
+                        'glm_per_gb_ram_month': annotations.get('golem_price_glm_ram_gb_month'),
+                        'glm_per_gb_storage_month': annotations.get('golem_price_glm_storage_gb_month'),
+                    },
                     'created_at_block': metadata.expires_at_block - (config.advertisement_interval * 2)
                 }
                 if provider['provider_id']:
@@ -225,6 +266,31 @@ class ProviderService:
 
         updated_at_str = await self._format_block_timestamp(provider.get('created_at_block', 0))
 
+        pricing = provider.get('pricing') or {}
+        usd_core = pricing.get('usd_per_core_month')
+        usd_ram = pricing.get('usd_per_gb_ram_month')
+        usd_storage = pricing.get('usd_per_gb_storage_month')
+
+        # Precompute estimates if a spec is set and pricing available
+        est_usd = '—'
+        est_glm = '—'
+        est_hr_usd = '—'
+        if self.estimate_spec and all(p is not None for p in (usd_core, usd_ram, usd_storage)):
+            spec_cpu, spec_mem, spec_sto = self.estimate_spec
+            try:
+                est_usd_val = (float(usd_core) * spec_cpu) + (float(usd_ram) * spec_mem) + (float(usd_storage) * spec_sto)
+                est_usd = round(est_usd_val, 4)
+                est_hr_usd = round(est_usd_val / 730.0, 6)
+                # If GLM per-unit is present, compute GLM estimate as well
+                glm_core = pricing.get('glm_per_core_month')
+                glm_ram = pricing.get('glm_per_gb_ram_month')
+                glm_storage = pricing.get('glm_per_gb_storage_month')
+                if all(x is not None for x in (glm_core, glm_ram, glm_storage)):
+                    est_glm_val = (float(glm_core) * spec_cpu) + (float(glm_ram) * spec_mem) + (float(glm_storage) * spec_sto)
+                    est_glm = round(est_glm_val, 8)
+            except Exception:
+                pass
+
         row = [
             provider['provider_id'],
             provider['provider_name'],
@@ -233,18 +299,38 @@ class ProviderService:
             provider['resources']['cpu'],
             provider['resources']['memory'],
             provider['resources']['storage'],
+            usd_core if usd_core is not None else '—',
+            usd_ram if usd_ram is not None else '—',
+            usd_storage if usd_storage is not None else '—',
+            est_usd,
+            est_glm,
             updated_at_str
         ]
 
         if colorize:
             # Format Provider ID
-            row[0] = style(row[0], fg="yellow")
+            id_txt = style(row[0], fg="yellow")
+            if est_hr_usd != '—':
+                id_txt += style(f"  (~${est_hr_usd}/hr)", fg="yellow")
+            row[0] = id_txt
 
             # Format resources with icons and colors
             row[4] = style(f"💻 {row[4]}", fg="cyan", bold=True)
             row[5] = style(f"🧠 {row[5]}", fg="cyan", bold=True)
             row[6] = style(f"💾 {row[6]}", fg="cyan", bold=True)
 
+            # Format pricing with currency markers
+            if usd_core != '—':
+                row[7] = style(f"${row[7]}/mo", fg="magenta")
+            if usd_ram != '—':
+                row[8] = style(f"${row[8]}/GB/mo", fg="magenta")
+            if usd_storage != '—':
+                row[9] = style(f"${row[9]}/GB/mo", fg="magenta")
+            if est_usd != '—':
+                row[10] = style(f"~${row[10]}/mo", fg="yellow", bold=True)
+            if est_glm != '—':
+                row[11] = style(f"~{row[11]} GLM/mo", fg="yellow")
+
             # Format location info
             row[3] = style(f"🌍 {row[3]}", fg="green", bold=True)
 
@@ -260,6 +346,11 @@ class ProviderService:
             "Country",
             "CPU",
             "Memory (GB)",
-            "Storage (GB)",
+            "Disk (GB)",
+            "USD/core/mo",
+            "USD/GB RAM/mo",
+            "USD/GB Disk/mo",
+            "Est. $/mo",
+            "Est. GLM/mo",
             "Updated"
         ]

requestor/services/vm_service.py

@@ -14,11 +14,13 @@ class VMService:
         self,
         db_service: DatabaseService,
         ssh_service: SSHService,
-        provider_client: Optional[ProviderClient] = None
+        provider_client: Optional[ProviderClient] = None,
+        blockchain_client: Optional[object] = None,
     ):
         self.db = db_service
         self.ssh_service = ssh_service
         self.provider_client = provider_client
+        self.blockchain_client = blockchain_client
 
     async def create_vm(
         self,
@@ -27,7 +29,8 @@ class VMService:
         memory: int,
         storage: int,
         provider_ip: str,
-        ssh_key: str
+        ssh_key: str,
+        stream_id: int | None = None,
     ) -> Dict:
         """Create a new VM with validation and error handling."""
         try:
@@ -42,18 +45,42 @@ class VMService:
                 cpu=cpu,
                 memory=memory,
                 storage=storage,
-                ssh_key=ssh_key
+                ssh_key=ssh_key,
+                stream_id=stream_id
             )
 
             # Get VM access info
             access_info = await self.provider_client.get_vm_access(vm['id'])
 
+            # Optionally create a GLM stream (if configured)
+            from ..config import config as app_config
+            stream_id = None
+            try:
+                if (
+                    self.blockchain_client
+                    and app_config.stream_payment_address != "0x0000000000000000000000000000000000000000"
+                    and app_config.glm_token_address != "0x0000000000000000000000000000000000000000"
+                    and app_config.provider_eth_address
+                ):
+                    # Simple heuristic: deposit for 1 hour at a nominal rate
+                    rate_per_second = 10**18  # 1 GLM / second (example)
+                    deposit = rate_per_second * 3600  # 1 hour worth
+                    stream_id = self.blockchain_client.create_stream(
+                        app_config.provider_eth_address,
+                        deposit,
+                        rate_per_second,
+                    )
+            except Exception:
+                # Do not fail VM creation if streaming setup fails
+                stream_id = None
+
             # Save VM details to database
             config = {
                 'cpu': cpu,
                 'memory': memory,
                 'storage': storage,
-                'ssh_port': access_info['ssh_port']
+                'ssh_port': access_info['ssh_port'],
+                **({"stream_id": stream_id} if stream_id is not None else {}),
             }
             await self.db.save_vm(
                 name=name,
@@ -88,6 +115,15 @@ class VMService:
                 if "Not Found" not in str(e):
                     raise
 
+            # Attempt to terminate stream if present
+            try:
+                stream_id = vm.get('config', {}).get('stream_id')
+                if stream_id is not None and self.blockchain_client:
+                    self.blockchain_client.terminate(stream_id)
+            except Exception:
+                # Best-effort: do not block deletion on chain failure
+                pass
+
             # Remove from database
             await self.db.delete_vm(name)
 
@@ -125,6 +161,14 @@ class VMService:
             # Update status in database
             await self.db.update_vm_status(name, "stopped")
 
+            # Best-effort withdraw on stop
+            try:
+                stream_id = vm.get('config', {}).get('stream_id')
+                if stream_id is not None and self.blockchain_client:
+                    self.blockchain_client.withdraw(stream_id)
+            except Exception:
+                pass
+
         except Exception as e:
             raise VMError(f"Failed to stop VM: {str(e)}")
 
@@ -195,7 +239,7 @@ class VMService:
             "SSH Port",
             "CPU",
             "Memory (GB)",
-            "Storage (GB)",
+            "Disk (GB)",
             "Connect Command",
             "Created"
         ]

requestor/ssh/manager.py

@@ -53,9 +53,17 @@ class SSHKeyManager:
         
         # Create Golem directory if needed
         self.golem_dir.mkdir(parents=True, exist_ok=True)
-        # Secure directory permissions (on Unix-like systems)
+        # Secure directory permissions (on Unix-like systems). If the directory
+        # is a system path (e.g., "/tmp") or not owned/permission-changeable
+        # by the current user, ignore the error to avoid test and runtime failures.
         if os.name == 'posix':
-            os.chmod(self.golem_dir, 0o700)
+            try:
+                os.chmod(self.golem_dir, 0o700)
+            except PermissionError:
+                logger.warning(
+                    "Could not set permissions on %s; continuing without chmod",
+                    self.golem_dir,
+                )
 
     async def get_key_pair(self) -> KeyPair:
         """Get the SSH key pair to use.