request-vm-on-golem 0.1.45__tar.gz → 0.1.47__tar.gz

{request_vm_on_golem-0.1.45 → request_vm_on_golem-0.1.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: request-vm-on-golem
-Version: 0.1.45
+Version: 0.1.47
 Summary: VM on Golem Requestor CLI - Create and manage virtual machines on the Golem Network
 Keywords: golem,vm,cloud,decentralized,cli
 Author: Phillip Jensen
@@ -158,6 +158,19 @@ poetry run golem vm stream topup --stream-id 123 --hours 3
 poetry run golem vm stream topup --stream-id 123 --glm 25.0
 ```
 
+- Check stream status via provider (by VM name recorded in your DB):
+
+```bash
+poetry run golem vm stream status my-vm
+# add --json for machine-readable output
+```
+
+- Inspect a stream directly on-chain:
+
+```bash
+poetry run golem vm stream inspect --stream-id 123
+```
+
 - Create a VM and attach an existing stream (no auto-streams are created by the requestor):
 
 ```bash
@@ -170,8 +183,9 @@ poetry run golem vm create my-vm \
 Environment (env prefix `GOLEM_REQUESTOR_`):
 
 - `polygon_rpc_url` — EVM RPC URL (default L2 RPC)
-- `stream_payment_address` — StreamPayment address (fallback if provider doesn’t advertise)
-- `glm_token_address` — Token address; set to zero address to use native ETH
+- `stream_payment_address` — StreamPayment address (defaults from `contracts/deployments/l2.json`; overridden by provider info)
+- `glm_token_address` — Token address (defaults from `contracts/deployments/l2.json`; zero address means native ETH)
+  - Optional override of deployments directory: set `GOLEM_DEPLOYMENTS_DIR` to a folder containing `l2.json`.
 - `provider_eth_address` — optional dev helper; in production always use `/provider/info`
 - `network` — Target network for discovery filtering: `testnet` (default) or `mainnet`
 

{request_vm_on_golem-0.1.45 → request_vm_on_golem-0.1.47}/README.md

@@ -117,6 +117,19 @@ poetry run golem vm stream topup --stream-id 123 --hours 3
 poetry run golem vm stream topup --stream-id 123 --glm 25.0
 ```
 
+- Check stream status via provider (by VM name recorded in your DB):
+
+```bash
+poetry run golem vm stream status my-vm
+# add --json for machine-readable output
+```
+
+- Inspect a stream directly on-chain:
+
+```bash
+poetry run golem vm stream inspect --stream-id 123
+```
+
 - Create a VM and attach an existing stream (no auto-streams are created by the requestor):
 
 ```bash
@@ -129,8 +142,9 @@ poetry run golem vm create my-vm \
 Environment (env prefix `GOLEM_REQUESTOR_`):
 
 - `polygon_rpc_url` — EVM RPC URL (default L2 RPC)
-- `stream_payment_address` — StreamPayment address (fallback if provider doesn’t advertise)
-- `glm_token_address` — Token address; set to zero address to use native ETH
+- `stream_payment_address` — StreamPayment address (defaults from `contracts/deployments/l2.json`; overridden by provider info)
+- `glm_token_address` — Token address (defaults from `contracts/deployments/l2.json`; zero address means native ETH)
+  - Optional override of deployments directory: set `GOLEM_DEPLOYMENTS_DIR` to a folder containing `l2.json`.
 - `provider_eth_address` — optional dev helper; in production always use `/provider/info`
 - `network` — Target network for discovery filtering: `testnet` (default) or `mainnet`
 

{request_vm_on_golem-0.1.45 → request_vm_on_golem-0.1.47}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "request-vm-on-golem"
-version = "0.1.45"
+version = "0.1.47"
 description = "VM on Golem Requestor CLI - Create and manage virtual machines on the Golem Network"
 authors = ["Phillip Jensen <phillip+vm-on-golem@golemgrid.com>"]
 readme = "README.md"
@@ -21,6 +21,11 @@ packages = [
     { include = "requestor" }
 ]
 
+# Include package data (deployment JSON)
+include = [
+    { path = "requestor/data/deployments/l2.json", format = "wheel" },
+]
+
 [tool.poetry.dependencies]
 python = "^3.11"
 click = "^8.0.1"

{request_vm_on_golem-0.1.45 → request_vm_on_golem-0.1.47}/requestor/cli/commands.py

@@ -186,10 +186,11 @@ async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Opt
 @click.option('--memory', type=int, required=True, help='Memory 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('--hours', type=int, default=1, help='If no stream-id is provided and payments are enabled, open a stream with this many hours of deposit (default 1)')
 @click.option('--yes', is_flag=True, help='Do not prompt for confirmation')
 @click.option('--network', type=click.Choice(['testnet', 'mainnet']), default=None, help='Override network for discovery during creation')
 @async_command
-async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage: int, stream_id: int | None, yes: bool, network: Optional[str] = None):
+async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage: int, stream_id: int | None, hours: int, yes: bool, network: Optional[str] = None):
     """Create a new VM on a specific provider."""
     try:
         if network:
@@ -227,10 +228,7 @@ async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage:
                 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
+                # For streamlined UX, proceed without an interactive confirmation
 
                 # Setup SSH
                 ssh_service = SSHService(config.ssh_key_dir)
@@ -239,8 +237,46 @@ async def create_vm(name: str, provider_id: str, cpu: int, memory: int, storage:
                 # Initialize VM service
                 provider_url = config.get_provider_url(provider_ip)
                 async with ProviderClient(provider_url) as client:
+                    # Fetch provider info if available (for preferred contract addresses); proceed regardless
+                    info = None
+                    try:
+                        info = await client.get_provider_info()
+                    except Exception:
+                        info = None
+                    # Always auto-open a stream when none provided (assume streaming required by default)
+                    if stream_id is None:
+                        # Compute rate from provider pricing
+                        est = provider_service.compute_estimate(provider, (cpu, memory, storage))
+                        if not est or est.get('glm_per_month') is None:
+                            raise RequestorError('Provider requires streaming but 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))
+                        deposit_wei = rate_per_second_wei * int(hours) * 3600
+                        # Auto-fund via faucet if needed (testnets), then create stream
+                        try:
+                            from eth_account import Account
+                            from ..security.faucet import L2FaucetService
+                            acct = Account.from_key(config.ethereum_private_key)
+                            faucet = L2FaucetService(config)
+                            await faucet.request_funds(acct.address)
+                        except Exception:
+                            # Non-fatal; stream creation may still succeed if already funded
+                            pass
+                        # Open stream on-chain
+                        from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
+                        spc = StreamPaymentConfig(
+                            rpc_url=config.polygon_rpc_url,
+                            contract_address=(info.get('stream_payment_address') if info else None) or config.stream_payment_address,
+                            glm_token_address=(info.get('glm_token_address') if info else None) or config.glm_token_address,
+                            private_key=config.ethereum_private_key,
+                        )
+                        sp_client = StreamPaymentClient(spc)
+                        recipient = (info.get('provider_id') if info else None) or provider_id
+                        stream_id = sp_client.create_stream(recipient, int(deposit_wei), int(rate_per_second_wei))
+                        logger.success(f"Opened stream id={stream_id} (hours={hours})")
+
                     vm_service = VMService(db_service, ssh_service, client)
-                    
                     # Create VM
                     vm = await vm_service.create_vm(
                         name=name,
@@ -384,6 +420,97 @@ async def stream_topup(stream_id: int, glm: float | None, hours: int | None):
         raise click.Abort()
 
 
+@vm_stream.command('status')
+@click.argument('name')
+@click.option('--json', 'as_json', is_flag=True, help='Output in JSON format')
+@async_command
+async def stream_status(name: str, as_json: bool):
+    """Show the payment stream status for a VM by name."""
+    try:
+        # Resolve VM and provider
+        vm = await db_service.get_vm(name)
+        if not vm:
+            raise RequestorError(f"VM '{name}' not found in local DB")
+        provider_url = config.get_provider_url(vm['provider_ip'])
+        async with ProviderClient(provider_url) as client:
+            status = await client.get_vm_stream_status(vm['vm_id'])
+        if as_json:
+            click.echo(json.dumps(status, indent=2))
+            return
+        # Pretty print
+        c = status.get('chain', {})
+        comp = status.get('computed', {})
+        click.echo("\n" + "─" * 60)
+        click.echo(click.style(f"  💸 Stream Status for VM: {name}", fg="blue", bold=True))
+        click.echo("─" * 60)
+        click.echo(f"  Stream ID     : {click.style(str(status.get('stream_id')), fg='cyan')}")
+        click.echo(f"  Verified      : {click.style(str(status.get('verified')), fg='green' if status.get('verified') else 'yellow')}")
+        click.echo(f"  Reason        : {status.get('reason')}")
+        click.echo("  On-chain      :")
+        click.echo(f"    recipient   : {c.get('recipient')} ")
+        click.echo(f"    startTime   : {c.get('startTime')}  stopTime: {c.get('stopTime')}")
+        click.echo(f"    rate/second : {c.get('ratePerSecond')}  deposit: {c.get('deposit')}  withdrawn: {c.get('withdrawn')}  halted: {c.get('halted')}")
+        click.echo("  Computed      :")
+        click.echo(f"    now         : {comp.get('now')}  remaining: {comp.get('remaining_seconds')}s")
+        click.echo(f"    vested      : {comp.get('vested_wei')}  withdrawable: {comp.get('withdrawable_wei')}")
+        click.echo("─" * 60)
+    except Exception as e:
+        logger.error(f"Failed to fetch stream status: {e}")
+        raise click.Abort()
+
+
+@vm_stream.command('inspect')
+@click.option('--stream-id', type=int, required=True)
+@click.option('--json', 'as_json', is_flag=True, help='Output in JSON format')
+@async_command
+async def stream_inspect(stream_id: int, as_json: bool):
+    """Inspect a stream directly on-chain (no provider required)."""
+    try:
+        from web3 import Web3
+        from golem_streaming_abi import STREAM_PAYMENT_ABI
+        w3 = Web3(Web3.HTTPProvider(config.polygon_rpc_url))
+        contract = w3.eth.contract(address=Web3.to_checksum_address(config.stream_payment_address), abi=STREAM_PAYMENT_ABI)
+        token, sender, recipient, startTime, stopTime, ratePerSecond, deposit, withdrawn, halted = contract.functions.streams(int(stream_id)).call()
+        now = int(w3.eth.get_block('latest')['timestamp'])
+        vested = max(min(now, int(stopTime)) - int(startTime), 0) * int(ratePerSecond)
+        withdrawable = max(int(vested) - int(withdrawn), 0)
+        remaining = max(int(stopTime) - now, 0)
+        out = {
+            "stream_id": int(stream_id),
+            "chain": {
+                "token": token,
+                "sender": sender,
+                "recipient": recipient,
+                "startTime": int(startTime),
+                "stopTime": int(stopTime),
+                "ratePerSecond": int(ratePerSecond),
+                "deposit": int(deposit),
+                "withdrawn": int(withdrawn),
+                "halted": bool(halted),
+            },
+            "computed": {
+                "now": now,
+                "remaining_seconds": remaining,
+                "vested_wei": int(vested),
+                "withdrawable_wei": int(withdrawable),
+            }
+        }
+        if as_json:
+            click.echo(json.dumps(out, indent=2))
+        else:
+            click.echo("\n" + "─" * 60)
+            click.echo(click.style(f"  🔎 On-chain Stream Inspect: {stream_id}", fg="blue", bold=True))
+            click.echo("─" * 60)
+            click.echo(f"  recipient     : {recipient}")
+            click.echo(f"  startTime     : {int(startTime)}  stopTime: {int(stopTime)}  now: {now}  remaining: {remaining}s")
+            click.echo(f"  rate/second   : {int(ratePerSecond)}  deposit: {int(deposit)}  withdrawn: {int(withdrawn)}  halted: {bool(halted)}")
+            click.echo(f"  vested        : {int(vested)}  withdrawable: {int(withdrawable)}")
+            click.echo("─" * 60)
+    except Exception as e:
+        logger.error(f"Failed to inspect stream: {e}")
+        raise click.Abort()
+
+
 @cli.group()
 def wallet():
     """Wallet utilities (funding, balance)."""

{request_vm_on_golem-0.1.45 → request_vm_on_golem-0.1.47}/requestor/config.py

@@ -106,12 +106,12 @@ class RequestorConfig(BaseSettings):
         description="EVM RPC URL for streaming payments (L2 by default)"
     )
     stream_payment_address: str = Field(
-        default="0x0000000000000000000000000000000000000000",
-        description="Deployed StreamPayment contract address"
+        default="",
+        description="Deployed StreamPayment contract address (defaults to contracts/deployments/l2.json)"
     )
     glm_token_address: str = Field(
-        default="0x0000000000000000000000000000000000000000",
-        description="Token address (0x0 means native ETH)"
+        default="",
+        description="Token address (0x0 means native ETH). Defaults from l2.json"
     )
     # Faucet settings (L2 payments)
     l2_faucet_url: str = Field(
@@ -145,6 +145,52 @@ class RequestorConfig(BaseSettings):
                 return os.environ[key]
         return v
 
+    @staticmethod
+    def _load_l2_deployment() -> tuple[str | None, str | None]:
+        try:
+            base = os.environ.get("GOLEM_DEPLOYMENTS_DIR")
+            if base:
+                path = Path(base) / "l2.json"
+            else:
+                # repo root assumption: ../../ relative to this file
+                path = Path(__file__).resolve().parents[2] / "contracts" / "deployments" / "l2.json"
+            if not path.exists():
+                # Try package resource fallback
+                try:
+                    import importlib.resources as ir
+                    with ir.files("requestor.data.deployments").joinpath("l2.json").open("r") as fh:  # type: ignore[attr-defined]
+                        import json as _json
+                        data = _json.load(fh)
+                except Exception:
+                    return None, None
+            else:
+                import json as _json
+                data = _json.loads(path.read_text())
+            sp = data.get("StreamPayment", {})
+            addr = sp.get("address")
+            token = sp.get("glmToken")
+            if isinstance(addr, str) and addr:
+                return addr, token or "0x0000000000000000000000000000000000000000"
+        except Exception:
+            pass
+        return None, None
+
+    @field_validator("stream_payment_address", mode='before')
+    @classmethod
+    def default_stream_addr(cls, v: str) -> str:
+        if v:
+            return v
+        addr, _ = RequestorConfig._load_l2_deployment()
+        return addr or "0x0000000000000000000000000000000000000000"
+
+    @field_validator("glm_token_address", mode='before')
+    @classmethod
+    def default_token_addr(cls, v: str) -> str:
+        if v:
+            return v
+        _, token = RequestorConfig._load_l2_deployment()
+        return token or "0x0000000000000000000000000000000000000000"
+
     # Base Directory
     base_dir: Path = Field(
         default_factory=lambda: Path.home() / ".golem" / "requestor",

request_vm_on_golem-0.1.47/requestor/data/deployments/l2.json

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

{request_vm_on_golem-0.1.45 → request_vm_on_golem-0.1.47}/requestor/provider/client.py

@@ -103,3 +103,13 @@ class ProviderClient:
                 error_text = await response.text()
                 raise Exception(f"Failed to get VM access info: {error_text}")
             return await response.json()
+
+    async def get_vm_stream_status(self, vm_id: str) -> Dict:
+        """Get on-chain stream status for a VM from provider."""
+        async with self.session.get(
+            f"{self.provider_url}/api/v1/vms/{vm_id}/stream"
+        ) as response:
+            if not response.ok:
+                error_text = await response.text()
+                raise Exception(f"Failed to get VM stream status: {error_text}")
+            return await response.json()