golem-vm-provider 0.1.51__tar.gz → 0.1.53__tar.gz

{golem_vm_provider-0.1.51 → golem_vm_provider-0.1.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.51
+Version: 0.1.53
 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
@@ -454,6 +454,8 @@ poetry run golem-provider streams withdraw --vm-id <vm_id>
 poetry run golem-provider streams withdraw --all
 ```
 
+Note: On testnets, the withdraw command auto-attempts to fund the provider's L2 address via the configured faucet if native gas balance is low.
+
 Configure monitor and withdraw via CLI:
 
 ```bash

{golem_vm_provider-0.1.51 → golem_vm_provider-0.1.53}/README.md

@@ -409,6 +409,8 @@ poetry run golem-provider streams withdraw --vm-id <vm_id>
 poetry run golem-provider streams withdraw --all
 ```
 
+Note: On testnets, the withdraw command auto-attempts to fund the provider's L2 address via the configured faucet if native gas balance is low.
+
 Configure monitor and withdraw via CLI:
 
 ```bash

{golem_vm_provider-0.1.51 → golem_vm_provider-0.1.53}/provider/main.py

@@ -147,38 +147,17 @@ def main():
 def wallet_faucet_l2():
     """Request L2 faucet funds for the provider's payment address (native ETH)."""
     from .config import settings
-    from golem_faucet import PowFaucetClient
-    from web3 import Web3
+    from .security.l2_faucet import L2FaucetService
     try:
         addr = settings.PROVIDER_ID
-        faucet = PowFaucetClient(settings.L2_FAUCET_URL, settings.L2_CAPTCHA_URL, settings.L2_CAPTCHA_API_KEY)
-        # Check current L2 balance
-        w3 = Web3(Web3.HTTPProvider(settings.POLYGON_RPC_URL))
-        bal = 0.0
-        try:
-            bal = float(w3.from_wei(w3.eth.get_balance(Web3.to_checksum_address(addr)), 'ether'))
-        except Exception:
-            pass
-        if bal > 0.01:
-            print(f"Sufficient L2 funds ({bal} ETH); skipping faucet.")
-            return
         async def _run():
-            chall = await faucet.get_challenge()
-            if not chall:
-                print("Failed to get challenge")
-                raise typer.Exit(code=1)
-            sols = []
-            for salt, target in chall.get('challenge') or []:
-                sols.append((salt, target, PowFaucetClient.solve_challenge(salt, target)))
-            redeemed = await faucet.redeem(chall.get('token'), sols)
-            if not redeemed:
-                print("Failed to redeem solutions")
-                raise typer.Exit(code=1)
-            tx = await faucet.request_funds(addr, redeemed)
+            svc = L2FaucetService(settings)
+            tx = await svc.request_funds(addr)
             if tx:
                 print(f"Faucet tx: {tx}")
             else:
-                print("Faucet request failed")
+                # Either skipped due to sufficient balance or failed
+                pass
         asyncio.run(_run())
     except Exception as e:
         print(f"Error: {e}")
@@ -191,6 +170,9 @@ def streams_list(json_out: bool = typer.Option(False, "--json", help="Output in
     from .container import Container
     from .config import settings
     from .payments.blockchain_service import StreamPaymentReader
+    from .utils.pricing import fetch_glm_usd_price, fetch_eth_usd_price
+    from decimal import Decimal
+    from web3 import Web3
     import json as _json
     try:
         if not settings.STREAM_PAYMENT_ADDRESS or settings.STREAM_PAYMENT_ADDRESS == "0x0000000000000000000000000000000000000000":
@@ -213,6 +195,7 @@ def streams_list(json_out: bool = typer.Option(False, "--json", help="Output in
                 rows.append({
                     "vm_id": vm_id,
                     "stream_id": int(stream_id),
+                    "token": str(s.get("token")),
                     "recipient": s["recipient"],
                     "start": int(s["startTime"]),
                     "stop": int(s["stopTime"]),
@@ -232,12 +215,66 @@ def streams_list(json_out: bool = typer.Option(False, "--json", help="Output in
         if not rows:
             print("No streams mapped.")
             return
-        print("\nStreams (VM → stream_id, remaining s, verified):")
+        # Prepare human-friendly display (ETH/GLM + USD)
+        ZERO = "0x0000000000000000000000000000000000000000"
+        # Cache prices so we don't query per-row
+        price_cache: dict[str, Optional[Decimal]] = {"ETH": None, "GLM": None}
+        # Determine which symbols are present
+        symbols_present = set()
         for r in rows:
             if "error" in r:
-                print(f"- {r['vm_id']}: {r['stream_id']} ERROR: {r['error']}")
-            else:
-                print(f"- {r['vm_id']}: {r['stream_id']} remaining={r['remaining']}s verified={r['verified']} reason={r['reason']} withdrawable={r['withdrawable']}")
+                continue
+            token_addr = (r.get("token") or "").lower()
+            sym = "ETH" if token_addr == ZERO.lower() else "GLM"
+            symbols_present.add(sym)
+        if "ETH" in symbols_present:
+            price_cache["ETH"] = fetch_eth_usd_price()
+        if "GLM" in symbols_present:
+            price_cache["GLM"] = fetch_glm_usd_price()
+
+        # Build table rows
+        table_rows = []
+        for r in rows:
+            if "error" in r:
+                table_rows.append([r["vm_id"], str(r["stream_id"]), "—", "ERROR", r.get("error", ""), "—"])
+                continue
+            token_addr = (r.get("token") or "").lower()
+            sym = "ETH" if token_addr == ZERO.lower() else "GLM"
+            withdrawable_eth = Decimal(str(Web3.from_wei(int(r["withdrawable"]), "ether")))
+            withdrawable_str = f"{withdrawable_eth:.6f} {sym}"
+            price = price_cache.get(sym)
+            usd_str = "—"
+            if price is not None:
+                try:
+                    usd_val = (withdrawable_eth * price).quantize(Decimal("0.01"))
+                    usd_str = f"${usd_val}"
+                except Exception:
+                    usd_str = "—"
+            table_rows.append([
+                r["vm_id"],
+                str(r["stream_id"]),
+                f"{int(r['remaining'])}s",
+                "yes" if r["verified"] else "no",
+                withdrawable_str,
+                usd_str,
+            ])
+
+        headers = ["VM", "Stream", "Remaining", "Verified", "Withdrawable", "USD"]
+        # Compute column widths
+        cols = len(headers)
+        col_widths = [len(h) for h in headers]
+        for row in table_rows:
+            for i in range(cols):
+                col_widths[i] = max(col_widths[i], len(str(row[i])))
+
+        def fmt_row(values: list[str]) -> str:
+            return "  ".join(str(values[i]).ljust(col_widths[i]) for i in range(cols))
+
+        print("\nStreams")
+        print(fmt_row(headers))
+        print("  ".join("-" * w for w in col_widths))
+        for row in table_rows:
+            print(fmt_row(row))
     except Exception as e:
         print(f"Error: {e}")
         raise typer.Exit(code=1)
@@ -249,6 +286,9 @@ def streams_show(vm_id: str = typer.Argument(..., help="VM id (requestor_name)")
     from .container import Container
     from .config import settings
     from .payments.blockchain_service import StreamPaymentReader
+    from .utils.pricing import fetch_glm_usd_price, fetch_eth_usd_price
+    from decimal import Decimal
+    from web3 import Web3
     import json as _json
     try:
         c = Container()
@@ -281,7 +321,43 @@ def streams_show(vm_id: str = typer.Argument(..., help="VM id (requestor_name)")
         if json_out:
             print(_json.dumps(out, indent=2))
         else:
-            print(f"VM {vm_id}: stream {sid} remaining={remaining}s verified={ok} withdrawable={withdrawable}")
+            ZERO = "0x0000000000000000000000000000000000000000"
+            token_addr = (s.get("token") or "").lower()
+            sym = "ETH" if token_addr == ZERO.lower() else "GLM"
+            nat = Decimal(str(Web3.from_wei(int(withdrawable), "ether")))
+            price = fetch_eth_usd_price() if sym == "ETH" else fetch_glm_usd_price()
+            usd_str = "—"
+            if price is not None:
+                try:
+                    usd_val = (nat * price).quantize(Decimal("0.01"))
+                    usd_str = f"${usd_val}"
+                except Exception:
+                    usd_str = "—"
+            def _fmt_seconds(sec: int) -> str:
+                m, s2 = divmod(int(sec), 60)
+                h, m = divmod(m, 60)
+                d, h = divmod(h, 24)
+                parts = []
+                if d: parts.append(f"{d}d")
+                if h: parts.append(f"{h}h")
+                if m and not d: parts.append(f"{m}m")
+                if s2 and not d and not h and not m: parts.append(f"{s2}s")
+                return " ".join(parts) or "0s"
+            # Pretty single-record display
+            print("\nStream Details")
+            headers = ["VM", "Stream", "Remaining", "Verified", "Withdrawable", "USD"]
+            cols = [
+                vm_id,
+                str(sid),
+                _fmt_seconds(remaining),
+                "yes" if ok else "no",
+                f"{nat:.6f} {sym}",
+                usd_str,
+            ]
+            w = [max(len(headers[i]), len(str(cols[i]))) for i in range(len(headers))]
+            print("  ".join(headers[i].ljust(w[i]) for i in range(len(w))))
+            print("  ".join("-" * wi for wi in w))
+            print("  ".join(str(cols[i]).ljust(w[i]) for i in range(len(w))))
     except Exception as e:
         print(f"Error: {e}")
         raise typer.Exit(code=1)
@@ -292,6 +368,9 @@ def streams_earnings(json_out: bool = typer.Option(False, "--json", help="Output
     from .container import Container
     from .config import settings
     from .payments.blockchain_service import StreamPaymentReader
+    from .utils.pricing import fetch_glm_usd_price, fetch_eth_usd_price
+    from decimal import Decimal
+    from web3 import Web3
     import json as _json
     try:
         c = Container()
@@ -304,6 +383,8 @@ def streams_earnings(json_out: bool = typer.Option(False, "--json", help="Output
         total_vested = 0
         total_withdrawn = 0
         total_withdrawable = 0
+        ZERO = "0x0000000000000000000000000000000000000000"
+        sums_native: dict[str, Decimal] = {"ETH": Decimal("0"), "GLM": Decimal("0")}
         for vm_id, stream_id in items.items():
             try:
                 s = reader.get_stream(int(stream_id))
@@ -312,9 +393,12 @@ def streams_earnings(json_out: bool = typer.Option(False, "--json", help="Output
                 total_vested += int(vested)
                 total_withdrawn += int(s["withdrawn"])  # type: ignore
                 total_withdrawable += int(withdrawable)
+                sym = "ETH" if (s.get("token") or "").lower() == ZERO.lower() else "GLM"
+                sums_native[sym] += Decimal(str(Web3.from_wei(int(withdrawable), "ether")))
                 rows.append({
                     "vm_id": vm_id,
                     "stream_id": int(stream_id),
+                    "token": str(s.get("token")),
                     "vested": int(vested),
                     "withdrawn": int(s["withdrawn"]),
                     "withdrawable": int(withdrawable),
@@ -332,17 +416,53 @@ def streams_earnings(json_out: bool = typer.Option(False, "--json", help="Output
         if json_out:
             print(_json.dumps(out, indent=2))
             return
-        print("\nEarnings summary (wei):")
-        print(f"  Vested total      : {total_vested}")
-        print(f"  Withdrawn total   : {total_withdrawn}")
-        print(f"  Withdrawable total: {total_withdrawable}")
+        # Human summary by token with USD
+        price_eth = fetch_eth_usd_price()
+        price_glm = fetch_glm_usd_price()
+        def _fmt_usd(amount_native: Decimal, price: Optional[Decimal]) -> str:
+            if price is None:
+                return "—"
+            try:
+                return f"${(amount_native * price).quantize(Decimal('0.01'))}"
+            except Exception:
+                return "—"
+        print("\nEarnings Summary")
+        headers = ["Token", "Withdrawable", "USD"]
+        data_rows = [
+            ["ETH", f"{sums_native['ETH']:.6f} ETH", _fmt_usd(sums_native["ETH"], price_eth)],
+            ["GLM", f"{sums_native['GLM']:.6f} GLM", _fmt_usd(sums_native["GLM"], price_glm)],
+        ]
+        # Table widths
+        w = [len(h) for h in headers]
+        for r in data_rows:
+            for i in range(3):
+                w[i] = max(w[i], len(str(r[i])))
+        print("  ".join(headers[i].ljust(w[i]) for i in range(3)))
+        print("  ".join("-" * wi for wi in w))
+        for r in data_rows:
+            print("  ".join(str(r[i]).ljust(w[i]) for i in range(3)))
+        # Per stream table
         if rows:
-            print("\nPer-stream:")
+            table = []
             for r in rows:
                 if "error" in r:
-                    print(f"- {r['vm_id']} [{r['stream_id']}] ERROR: {r['error']}")
-                else:
-                    print(f"- {r['vm_id']} [{r['stream_id']}]: vested={r['vested']} withdrawn={r['withdrawn']} withdrawable={r['withdrawable']}")
+                    table.append([r["vm_id"], str(r["stream_id"]), "ERROR", r.get("error", "")])
+                    continue
+                sym = "ETH" if (r.get("token") or "").lower() == ZERO.lower() else "GLM"
+                nat = Decimal(str(Web3.from_wei(int(r["withdrawable"]), "ether")))
+                price = price_eth if sym == "ETH" else price_glm
+                usd = _fmt_usd(nat, price)
+                table.append([r["vm_id"], str(r["stream_id"]), f"{nat:.6f} {sym}", usd])
+            h2 = ["VM", "Stream", "Withdrawable", "USD"]
+            w2 = [len(x) for x in h2]
+            for row in table:
+                for i in range(4):
+                    w2[i] = max(w2[i], len(str(row[i])))
+            print("\nPer Stream")
+            print("  ".join(h2[i].ljust(w2[i]) for i in range(4)))
+            print("  ".join("-" * wi for wi in w2))
+            for row in table:
+                print("  ".join(str(row[i]).ljust(w2[i]) for i in range(4)))
     except Exception as e:
         print(f"Error: {e}")
         raise typer.Exit(code=1)
@@ -356,6 +476,7 @@ def streams_withdraw(
     """Withdraw vested funds for one or all streams."""
     from .container import Container
     from .config import settings
+    from .security.l2_faucet import L2FaucetService
     try:
         if not vm_id and not all_streams:
             print("Specify --vm-id or --all")
@@ -364,6 +485,12 @@ def streams_withdraw(
         c.config.from_pydantic(settings)
         stream_map = c.stream_map()
         client = c.stream_client()
+        # Ensure we have L2 gas for withdrawals (testnets)
+        try:
+            asyncio.run(L2FaucetService(settings).request_funds(settings.PROVIDER_ID))
+        except Exception:
+            # Non-fatal; proceed with withdraw attempt
+            pass
         targets = []
         if all_streams:
             items = asyncio.run(stream_map.all_items())

golem_vm_provider-0.1.53/provider/security/l2_faucet.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Optional, List, Tuple
+
+from web3 import Web3
+from golem_faucet import PowFaucetClient
+from ..utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class L2FaucetService:
+    """Request native ETH on the L2 payments chain via PoW faucet.
+
+    Uses provider settings for RPC and faucet endpoints.
+    """
+
+    def __init__(self, config):
+        # Config is expected to expose POLYGON_RPC_URL, L2_* faucet fields
+        self.cfg = config
+        self.web3 = Web3(Web3.HTTPProvider(config.POLYGON_RPC_URL))
+        self.client = PowFaucetClient(
+            faucet_url=getattr(config, "L2_FAUCET_URL", "https://l2.holesky.golemdb.io/faucet"),
+            captcha_base_url=getattr(config, "L2_CAPTCHA_URL", "https://cap.gobas.me"),
+            captcha_api_key=getattr(config, "L2_CAPTCHA_API_KEY", "05381a2cef5e"),
+        )
+
+    def _balance_eth(self, address: str) -> float:
+        try:
+            wei = self.web3.eth.get_balance(Web3.to_checksum_address(address))
+            return float(self.web3.from_wei(wei, "ether"))
+        except Exception as e:
+            logger.warning(f"L2 balance check failed: {e}")
+            return 0.0
+
+    async def request_funds(self, address: str) -> Optional[str]:
+        """Ensure some native ETH on L2; if low, solve PoW and request faucet payout.
+
+        Returns tx hash string on payout, or None if skipped/failed.
+        """
+        bal = self._balance_eth(address)
+        if bal > 0.01:
+            logger.info(f"Sufficient L2 funds ({bal} ETH), skipping faucet.")
+            return None
+        chall = await self.client.get_challenge()
+        if not chall:
+            logger.error("could not fetch faucet challenge")
+            return None
+        token = chall.get("token")
+        challenge_list = chall.get("challenge") or []
+        solutions: List[Tuple[str, str, int]] = []
+        for salt, target in challenge_list:
+            nonce = PowFaucetClient.solve_challenge(salt, target)
+            solutions.append((salt, target, nonce))
+        redeemed = await self.client.redeem(token, solutions)
+        if not redeemed:
+            logger.error("failed to redeem challenge")
+            return None
+        tx = await self.client.request_funds(address, redeemed)
+        if tx:
+            logger.success(f"L2 faucet sent tx: {tx}")
+        return tx
+

{golem_vm_provider-0.1.51 → golem_vm_provider-0.1.53}/provider/utils/pricing.py

@@ -47,6 +47,14 @@ def fetch_glm_usd_price() -> Optional[Decimal]:
     return _coingecko_simple_price(settings.COINGECKO_IDS)
 
 
+def fetch_eth_usd_price() -> Optional[Decimal]:
+    """Fetch the current ETH price in USD from CoinGecko.
+
+    Uses the canonical "ethereum" id.
+    """
+    return _coingecko_simple_price("ethereum")
+
+
 def usd_to_glm(usd_amount: Decimal, glm_usd: Decimal) -> Decimal:
     if glm_usd <= 0:
         raise ValueError("Invalid GLM/USD price")

{golem_vm_provider-0.1.51 → golem_vm_provider-0.1.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "golem-vm-provider"
-version = "0.1.51"
+version = "0.1.53"
 description = "VM on Golem Provider Node - Run your own provider node to offer VMs on the Golem Network"
 authors = ["Phillip Jensen <phillip+vm-on-golem@golemgrid.com>"]
 readme = "README.md"