golem-vm-provider 0.1.50__py3-none-any.whl → 0.1.52__py3-none-any.whl

{golem_vm_provider-0.1.50.dist-info → golem_vm_provider-0.1.52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.50
+Version: 0.1.52
 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
@@ -436,6 +436,34 @@ poetry run golem-provider streams list --json
 poetry run golem-provider streams show <vm_id>
 ```
 
+- Summarize earnings and withdrawable amounts:
+
+```bash
+poetry run golem-provider streams earnings
+# or JSON
+poetry run golem-provider streams earnings --json
+```
+
+- Withdraw vested funds:
+
+```bash
+# One VM by id
+poetry run golem-provider streams withdraw --vm-id <vm_id>
+
+# All mapped streams
+poetry run golem-provider streams withdraw --all
+```
+
+Configure monitor and withdraw via CLI:
+
+```bash
+# Set monitor to require 1h remaining, check every 30s
+poetry run golem-provider config monitor --enable true --interval 30 --min-remaining 3600
+
+# Enable auto-withdraw every 15 minutes when >= 1e15 wei
+poetry run golem-provider config withdraw --enable true --interval 900 --min-wei 1000000000000000
+```
+
 ### Resource Advertisement Flow
 
 ```mermaid

{golem_vm_provider-0.1.50.dist-info → golem_vm_provider-0.1.52.dist-info}/RECORD

@@ -13,7 +13,7 @@ provider/discovery/multi_advertiser.py,sha256=_J79wA1-XQ4GsLzt9KrKpWigGSGBqtut7D
 provider/discovery/resource_monitor.py,sha256=AmiEc7yBGEGXCunQ-QKmVgosDX3gOhK1Y58LJZXrwAs,949
 provider/discovery/resource_tracker.py,sha256=MP7IXd3aIMsjB4xz5Oj9zFDTEnvrnw-Cyxpl33xcJcc,6006
 provider/discovery/service.py,sha256=vX_mVSxvn3arnb2cKDM_SeJp1ZgPdImP2aUubeXgdRg,915
-provider/main.py,sha256=RSq2_dbBjQYkNwohxuwgzKbnzcqzEgJH1wcPMMf00t0,18925
+provider/main.py,sha256=-dkQEwMrU2g1ljGrdf2B6P6CcgpDAjeCEqbBy_E4ybk,32799
 provider/network/port_verifier.py,sha256=3l6WNwBHydggJRFYkAsuBp1eCxaU619kjWuM-zSVj2o,13267
 provider/payments/blockchain_service.py,sha256=4GrzDKwCSUVoENqjD4RLyJ0qwBOJKMyVk5Li-XNsyTc,3567
 provider/payments/monitor.py,sha256=Rw17zYsxZre0zU6R0oeRNvVIzMdXLsgoUvSPHpJy6I0,4488
@@ -25,7 +25,7 @@ provider/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 provider/utils/ascii_art.py,sha256=ykBFsztk57GIiz1NJ-EII5UvN74iECqQL4h9VmiW6Z8,3161
 provider/utils/logging.py,sha256=VV3oTYSRT8hUejtXLuua1M6kCHmIJgPspIkzsUVhYW0,1920
 provider/utils/port_display.py,sha256=u1HWQFA2kPbsM-TnsQfL6Hr4KmjIZWZfsjoxarHpbW0,11981
-provider/utils/pricing.py,sha256=e8obIH3yan8HsXJXoFvyh7eS1DtXJT5NZediPWhmJ0k,6113
+provider/utils/pricing.py,sha256=uTgiBJ04LuVPKkzwMTVTb6Jb7m_Z3o5XLsoMh49ixqY,6315
 provider/utils/retry.py,sha256=GvBjpr0DpTOgw28M2hI0yt17dpYLRwrxUUqVxWHQPtM,3148
 provider/utils/setup.py,sha256=Z5dLuBQkb5vdoQsu1HJZwXmu9NWsiBYJ7Vq9-C-_tY8,2932
 provider/vm/__init__.py,sha256=LJL504QGbqZvBbMN3G9ixMgAwvOWAKW37zUm_EiaW9M,508
@@ -38,7 +38,7 @@ provider/vm/port_manager.py,sha256=iYSwjTjD_ziOhG8aI7juKHw1OwwRUTJQyQoRUNQvz9w,1
 provider/vm/provider.py,sha256=A7QN89EJjcSS40_SmKeinG1Jp_NGffJaLse-XdKciAs,1164
 provider/vm/proxy_manager.py,sha256=n4NTsyz2rtrvjtf_ceKBk-g2q_mzqPwruB1q7UlQVBc,14928
 provider/vm/service.py,sha256=Ki4SGNIZUq3XmaPMwAOoNzdZzKQsmFXid374wgjFPes,4636
-golem_vm_provider-0.1.50.dist-info/METADATA,sha256=h4dTmyA9UOyvi8R3pp13bW34sxr8W8JSoYzALN8gRmA,16585
-golem_vm_provider-0.1.50.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-golem_vm_provider-0.1.50.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
-golem_vm_provider-0.1.50.dist-info/RECORD,,
+golem_vm_provider-0.1.52.dist-info/METADATA,sha256=-9IAEK4SfcsssCSwvniqN0hBaIvw3V8yxpEi9plknLw,17288
+golem_vm_provider-0.1.52.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.52.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
+golem_vm_provider-0.1.52.dist-info/RECORD,,

provider/main.py

@@ -132,6 +132,8 @@ streams_app = typer.Typer(help="Inspect payment streams")
 cli.add_typer(pricing_app, name="pricing")
 cli.add_typer(wallet_app, name="wallet")
 cli.add_typer(streams_app, name="streams")
+config_app = typer.Typer(help="Configure stream monitoring and withdrawals")
+cli.add_typer(config_app, name="config")
 
 @cli.callback()
 def main():
@@ -189,6 +191,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":
@@ -211,6 +216,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"]),
@@ -230,12 +236,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)
@@ -247,6 +307,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()
@@ -279,7 +342,189 @@ 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)
+
+@streams_app.command("earnings")
+def streams_earnings(json_out: bool = typer.Option(False, "--json", help="Output in JSON")):
+    """Summarize provider earnings: vested, withdrawn, and withdrawable totals."""
+    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()
+        c.config.from_pydantic(settings)
+        stream_map = c.stream_map()
+        reader = StreamPaymentReader(settings.POLYGON_RPC_URL, settings.STREAM_PAYMENT_ADDRESS)
+        items = asyncio.run(stream_map.all_items())
+        now = int(reader.web3.eth.get_block("latest")["timestamp"]) if items else 0
+        rows = []
+        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))
+                vested = max(min(now, int(s["stopTime"])) - int(s["startTime"]), 0) * int(s["ratePerSecond"])  # type: ignore
+                withdrawable = max(int(vested) - int(s["withdrawn"]), 0)
+                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),
+                })
+            except Exception as e:
+                rows.append({"vm_id": vm_id, "stream_id": int(stream_id), "error": str(e)})
+        out = {
+            "streams": rows,
+            "totals": {
+                "vested": int(total_vested),
+                "withdrawn": int(total_withdrawn),
+                "withdrawable": int(total_withdrawable),
+            }
+        }
+        if json_out:
+            print(_json.dumps(out, indent=2))
+            return
+        # 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:
+            table = []
+            for r in rows:
+                if "error" in r:
+                    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)
+
+
+@streams_app.command("withdraw")
+def streams_withdraw(
+    vm_id: str = typer.Option(None, "--vm-id", help="Withdraw for a single VM id"),
+    all_streams: bool = typer.Option(False, "--all", help="Withdraw for all mapped streams"),
+):
+    """Withdraw vested funds for one or all streams."""
+    from .container import Container
+    from .config import settings
+    try:
+        if not vm_id and not all_streams:
+            print("Specify --vm-id or --all")
+            raise typer.Exit(code=1)
+        c = Container()
+        c.config.from_pydantic(settings)
+        stream_map = c.stream_map()
+        client = c.stream_client()
+        targets = []
+        if all_streams:
+            items = asyncio.run(stream_map.all_items())
+            for vid, sid in items.items():
+                targets.append((vid, int(sid)))
+        else:
+            sid = asyncio.run(stream_map.get(vm_id))
+            if sid is None:
+                print("No stream mapped for this VM.")
+                raise typer.Exit(code=1)
+            targets.append((vm_id, int(sid)))
+        results = []
+        for vid, sid in targets:
+            try:
+                tx = client.withdraw(int(sid))
+                results.append((vid, sid, tx))
+                print(f"Withdrew stream {sid} for VM {vid}: tx={tx}")
+            except Exception as e:
+                print(f"Failed to withdraw stream {sid} for VM {vid}: {e}")
+        # no JSON aggregation here; use earnings for structured output
     except Exception as e:
         print(f"Error: {e}")
         raise typer.Exit(code=1)
@@ -331,6 +576,80 @@ def _write_env_vars(path: str, updates: dict):
     with open(path, "w") as f:
         f.writelines(out)
 
+
+@config_app.command("withdraw")
+def config_withdraw(
+    enable: bool = typer.Option(None, "--enable", help="Enable/disable auto-withdraw (true/false)"),
+    interval: int = typer.Option(None, "--interval", help="Withdraw interval in seconds (e.g., 1800)"),
+    min_wei: int = typer.Option(None, "--min-wei", help="Only withdraw when >= this wei amount"),
+    dev: bool = typer.Option(False, "--dev", help="Write to .env.dev instead of .env"),
+):
+    """Configure provider auto-withdraw settings and persist to .env(.dev)."""
+    from .config import settings
+    env_path = _env_path_for(dev)
+    updates = {}
+    if enable is not None:
+        updates["GOLEM_PROVIDER_STREAM_WITHDRAW_ENABLED"] = str(enable).lower()
+        settings.STREAM_WITHDRAW_ENABLED = bool(enable)
+    if interval is not None:
+        if interval < 0:
+            raise typer.BadParameter("--interval must be >= 0")
+        updates["GOLEM_PROVIDER_STREAM_WITHDRAW_INTERVAL_SECONDS"] = int(interval)
+        try:
+            settings.STREAM_WITHDRAW_INTERVAL_SECONDS = int(interval)
+        except Exception:
+            pass
+    if min_wei is not None:
+        if min_wei < 0:
+            raise typer.BadParameter("--min-wei must be >= 0")
+        updates["GOLEM_PROVIDER_STREAM_MIN_WITHDRAW_WEI"] = int(min_wei)
+        try:
+            settings.STREAM_MIN_WITHDRAW_WEI = int(min_wei)
+        except Exception:
+            pass
+    if not updates:
+        print("No changes (use --enable/--interval/--min-wei)")
+        raise typer.Exit(code=0)
+    _write_env_vars(env_path, updates)
+    print(f"Updated withdraw settings in {env_path}")
+
+
+@config_app.command("monitor")
+def config_monitor(
+    enable: bool = typer.Option(None, "--enable", help="Enable/disable stream monitor (true/false)"),
+    interval: int = typer.Option(None, "--interval", help="Monitor interval in seconds (e.g., 30)"),
+    min_remaining: int = typer.Option(None, "--min-remaining", help="Minimum remaining runway to keep VM running (seconds)"),
+    dev: bool = typer.Option(False, "--dev", help="Write to .env.dev instead of .env"),
+):
+    """Configure provider stream monitor and persist to .env(.dev)."""
+    from .config import settings
+    env_path = _env_path_for(dev)
+    updates = {}
+    if enable is not None:
+        updates["GOLEM_PROVIDER_STREAM_MONITOR_ENABLED"] = str(enable).lower()
+        settings.STREAM_MONITOR_ENABLED = bool(enable)
+    if interval is not None:
+        if interval < 0:
+            raise typer.BadParameter("--interval must be >= 0")
+        updates["GOLEM_PROVIDER_STREAM_MONITOR_INTERVAL_SECONDS"] = int(interval)
+        try:
+            settings.STREAM_MONITOR_INTERVAL_SECONDS = int(interval)
+        except Exception:
+            pass
+    if min_remaining is not None:
+        if min_remaining < 0:
+            raise typer.BadParameter("--min-remaining must be >= 0")
+        updates["GOLEM_PROVIDER_STREAM_MIN_REMAINING_SECONDS"] = int(min_remaining)
+        try:
+            settings.STREAM_MIN_REMAINING_SECONDS = int(min_remaining)
+        except Exception:
+            pass
+    if not updates:
+        print("No changes (use --enable/--interval/--min-remaining)")
+        raise typer.Exit(code=0)
+    _write_env_vars(env_path, updates)
+    print(f"Updated monitor settings in {env_path}")
+
 def _print_pricing_examples(glm_usd):
     from decimal import Decimal
     from .utils.pricing import calculate_monthly_cost, calculate_monthly_cost_usd

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