request-vm-on-golem 0.1.50__py3-none-any.whl → 0.1.52__py3-none-any.whl

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: request-vm-on-golem
-Version: 0.1.50
+Version: 0.1.52
 Summary: VM on Golem Requestor CLI - Create and manage virtual machines on the Golem Network
 Keywords: golem,vm,cloud,decentralized,cli
 Author: Phillip Jensen
@@ -41,7 +41,40 @@ Description-Content-Type: text/markdown
 
 # VM on Golem Requestor
 
-A sophisticated command-line interface for managing virtual machines on the Golem Network. The requestor works in tandem with provider nodes to create and manage VMs with secure SSH access.
+Rent compute on demand — like Airbnb for servers. The `golem` CLI helps you discover providers, fund pay‑as‑you‑go streams, launch VMs, and connect via SSH.
+
+## Quick Start (Rent a VM)
+
+1) Install:
+
+```bash
+pip install request-vm-on-golem
+```
+
+2) Find providers (testnet by default):
+
+```bash
+golem vm providers
+```
+
+3) Create a VM (auto‑opens a payment stream if needed):
+
+```bash
+golem vm create my-vm --provider-id 0xProvider --cpu 2 --memory 4 --storage 20
+```
+
+4) SSH in:
+
+```bash
+golem vm ssh my-vm
+```
+
+5) Stop or destroy when done:
+
+```bash
+golem vm stop my-vm
+golem vm destroy my-vm
+```
 
 ## Architecture Overview
 
@@ -141,7 +174,7 @@ CLI helpers
 - Open a stream for a planned VM (computes rate from provider pricing):
 
 ```bash
-poetry run golem vm stream open \
+golem vm stream open \
   --provider-id 0xProvider \
   --cpu 2 --memory 4 --storage 20 \
   --hours 1
@@ -152,29 +185,39 @@ poetry run golem vm stream open \
 
 ```bash
 # Add 3 hours at prior rate
-poetry run golem vm stream topup --stream-id 123 --hours 3
+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
+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
+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
+golem vm stream inspect --stream-id 123
+```
+
+- Stopping or destroying a VM ends the stream:
+
+```bash
+# Stop VM and terminate payment stream (best-effort)
+golem vm stop my-vm
+
+# Destroy VM and terminate stream
+golem vm destroy my-vm
 ```
 
 - Create a VM and attach an existing stream (no auto-streams are created by the requestor):
 
 ```bash
-poetry run golem vm create my-vm \
+golem vm create my-vm \
   --provider-id 0xProvider \
   --cpu 2 --memory 4 --storage 20 \
   --stream-id 123
@@ -182,7 +225,8 @@ poetry run golem vm create my-vm \
 
 Environment (env prefix `GOLEM_REQUESTOR_`):
 
-- `polygon_rpc_url` — EVM RPC URL (default L2 RPC)
+- `payments_network` — Payments network profile (defaults to `l2.holesky`). Profiles provide RPC + faucet defaults.
+- `polygon_rpc_url` — EVM RPC URL (defaults from `payments_network` profile; can be overridden)
 - `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`.
@@ -195,16 +239,21 @@ Efficiency tips:
 - Withdrawals are typically executed by providers; requestors don’t need to withdraw.
 - The CLI `vm stream open` will prefer the provider’s advertised contract/token addresses to prevent mismatches.
 
-## Faucet (L2 ETH)
+Monitoring and auto top-up:
+
+- The requestor API runs a background monitor that keeps each running VM’s stream funded with at least 1 hour runway (configurable). It checks every 30s and tops up to the target runway.
+- Configure via env (prefix `GOLEM_REQUESTOR_`): `stream_monitor_enabled` (default true), `stream_monitor_interval_seconds` (default 30), `stream_min_remaining_seconds` (default 3600), `stream_topup_target_seconds` (default 3600).
+
+## Faucet (Testnet only)
 
 - Request L2 test ETH to cover stream transactions:
 
 ```bash
-poetry run golem wallet faucet
+golem wallet faucet
 ```
 
 - Defaults:
-  - Faucet: `https://l2.holesky.golemdb.io/faucet`
+  - Faucet URL and enablement come from the active `payments_network` profile. On `mainnet` (or other profiles without faucet) the command is disabled.
   - CAPTCHA: `https://cap.gobas.me/05381a2cef5e`
   - Override with env: `GOLEM_REQUESTOR_l2_faucet_url`, `GOLEM_REQUESTOR_captcha_url`, `GOLEM_REQUESTOR_captcha_api_key`.
 
@@ -212,7 +261,7 @@ poetry run golem wallet faucet
 
 ```bash
 # Install using pip
-pip install golem-vm-requestor
+pip install request-vm-on-golem
 
 # Or install from source
 git clone https://github.com/golem/vm-on-golem.git
@@ -234,11 +283,7 @@ First, source the development environment variables:
 source .env.dev
 ```
 
-Then, run any `golem` command. For example:
-
-```bash
-poetry run golem vm providers
-```
+Then, run any `golem` command. For example: `golem vm providers`
 
 ### Prepending variables
 
@@ -255,19 +300,15 @@ GOLEM_REQUESTOR_ENVIRONMENT="development" GOLEM_REQUESTOR_FORCE_LOCALHOST="true"
   - Does not determine chain selection.
 
 - Network Selection (`--network` or `GOLEM_REQUESTOR_NETWORK`)
-  - Filters Golem Base discovery results by `golem_network=testnet|mainnet`.
-  - Combine with the appropriate RPC envs (`GOLEM_REQUESTOR_GOLEM_BASE_RPC_URL`, `GOLEM_REQUESTOR_GOLEM_BASE_WS_URL`) and any contract addresses.
-  - Independent from dev ergonomics.
+  - Filters results by `testnet|mainnet`. Defaults are sensible; most users don’t need to change anything.
+
+- Payments Network (`GOLEM_REQUESTOR_PAYMENTS_NETWORK`)
+  - Selects the payments chain profile (e.g., `l2.holesky`, `mainnet`) used for streaming payments; sets default RPC and faucet behavior.
+  - Provider discovery filters by this payments network via `vm providers` unless `--all-payments` is supplied. Override payments filter with `--payments-network <name>`.
 
 Examples:
-- List providers on mainnet without changing env:
-  ```bash
-  poetry run golem vm providers --network mainnet
-  ```
-- Create a VM while targeting testnet:
-  ```bash
-  poetry run golem vm create my-vm --provider-id 0xProvider --cpu 2 --memory 4 --storage 20 --network testnet
-  ```
+- List providers on mainnet without changing env: `golem vm providers --network mainnet`
+- Create a VM while targeting testnet: `golem vm create my-vm --provider-id 0xProvider --cpu 2 --memory 4 --storage 20 --network testnet`
 
 ## Usage
 
@@ -373,9 +414,6 @@ The requestor uses a hierarchical configuration system:
 1. Environment Variables:
 
 ```bash
-# Discovery Service
-export GOLEM_REQUESTOR_DISCOVERY_URL="http://discovery.golem.network:9001"
-
 # Base Directory (default: ~/.golem)
 export GOLEM_REQUESTOR_BASE_DIR="/path/to/golem/dir"
 
@@ -386,7 +424,7 @@ export GOLEM_REQUESTOR_DB_PATH="/path/to/database.db"
 # Environment Mode (defaults to "production")
 export GOLEM_REQUESTOR_ENVIRONMENT="development"  # Optional: Switch to development mode
 export GOLEM_REQUESTOR_FORCE_LOCALHOST="true"    # Optional: Force localhost in development mode
-export GOLEM_REQUESTOR_NETWORK="testnet"         # Or "mainnet"; filters Golem Base results by annotation
+export GOLEM_REQUESTOR_NETWORK="testnet"         # Or "mainnet"; optional filter for listing/creation
 ```
 
 2. Directory Structure:
@@ -423,7 +461,7 @@ Local state is maintained in SQLite:
 
 The requestor communicates with providers through:
 
-1. Discovery service for provider location
+1. Network discovery (uses sane defaults; no setup required for most users)
 2. Direct API calls for VM management
 3. SSH proxy system for secure access
 4. Resource tracking for capacity management

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

@@ -1,27 +1,28 @@
 requestor/__init__.py,sha256=OqSUAh1uZBMx7GW0MoSMg967PVdmT8XdPJx3QYjwkak,116
-requestor/api/main.py,sha256=7utCzFNbh5Ol-vsBWeSwT4lXeHD7zdA-GFZuS3rHMWc,2180
+requestor/api/main.py,sha256=CTnaM7KyBtDwVlyclYbNDy-nGi5_xt9GTcGusRasDVY,2493
 requestor/cli/__init__.py,sha256=e3E4oEGxmGj-STPtFkQwg_qIWhR0JAiAQdw3G1hXciU,37
-requestor/cli/commands.py,sha256=JfDvDYNvji1uIUF-0fHEHZxLzHWl-NslBdG1Yw2sFuY,45748
-requestor/config.py,sha256=2ayNJzvIIoU0jMAVqbs-yfG4H63W_uALLScBG4EjUOw,8241
+requestor/cli/commands.py,sha256=LILQeW8-aqosSkCU4iVzov542y8m5bggSO4yJi__qSk,48544
+requestor/config.py,sha256=GPsr_NSj04MD40mH6xyVY5FB0ysFDwJk9FJ5h9OQuJ0,12716
 requestor/data/deployments/l2.json,sha256=XTNN2C5LkBfp4YbDKdUKfWMdp1fKnfv8D3TgcwVWxtQ,249
 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=CACvZH2ZstutX7f0L_PXl8K_V5WlIkxNYIaeJuhP5I0,7500
+requestor/payments/monitor.py,sha256=JtSnh2plFf-f8sJU-bkOpadhoK_R82_ULwkDRmBYSbc,6012
 requestor/provider/__init__.py,sha256=fmW23aYUVciF8-gmBZkG-PLhn22upmcDzdPfAOLHG6g,103
 requestor/provider/client.py,sha256=pfJymufYR13W4kfykHZSVvs6ikRUE5AdHp0W0DB17AE,4130
 requestor/run.py,sha256=GqOG6n34szt8Sp3SEqjRV6huWm737yCN6YnBqoiwI-U,1785
-requestor/security/faucet.py,sha256=35d8mD3fM0YqRIhUXuIKandOL8vbw2T2IFQWVsan9Lw,2056
+requestor/security/faucet.py,sha256=XF_13b66SKAaY0-40hNRcSgC8AZA4mD5gyXl3qaBLpQ,2320
 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=eb4t6tkcw9VzJev2sfawT1KvVc5TxQnb1pgYgoQZcM4,15000
+requestor/services/provider_service.py,sha256=UjCg6YOwhkclJ227gXfI5uCTinhBv6Jjfsgxq0x0ESo,15701
 requestor/services/ssh_service.py,sha256=tcOCtk2SlB9Uuv-P2ghR22e7BJ9kigQh5b4zSGdPFns,4280
-requestor/services/vm_service.py,sha256=eQ2pPMpYlfPVbVFrkFElsRO5swPq-2XZEfuvxagyHDk,7941
+requestor/services/vm_service.py,sha256=1EUypRbCykdQTVJf4gYiNzkZNk66T3df32Vc51HkSMI,7983
 requestor/ssh/__init__.py,sha256=hNgSqJ5s1_AwwxVRyFjUqh_LTBpI4Hmzq0F-f_wXN9g,119
 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.50.dist-info/METADATA,sha256=EWV0bEfyWQeyBldHWHx3nUgOmZmD_5b5K6Btyp6VQt4,14363
-request_vm_on_golem-0.1.50.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-request_vm_on_golem-0.1.50.dist-info/entry_points.txt,sha256=Z-skRNpJ8aZcIl_En9mEm1ygkp9FKy0bzQoL3zO52-0,44
-request_vm_on_golem-0.1.50.dist-info/RECORD,,
+request_vm_on_golem-0.1.52.dist-info/METADATA,sha256=Spq__-pjr5GGH2oN0FTrfFZ5EvmicP4l0IpCXoUQu2A,15687
+request_vm_on_golem-0.1.52.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+request_vm_on_golem-0.1.52.dist-info/entry_points.txt,sha256=Z-skRNpJ8aZcIl_En9mEm1ygkp9FKy0bzQoL3zO52-0,44
+request_vm_on_golem-0.1.52.dist-info/RECORD,,

requestor/api/main.py

@@ -5,11 +5,13 @@ from contextlib import asynccontextmanager
 from ..services.database_service import DatabaseService
 from ..config import config
 from ..errors import DatabaseError
+from ..payments.monitor import RequestorStreamMonitor
 
 logger = logging.getLogger(__name__)
 
 # Global variable to hold the database service instance
 db_service: DatabaseService = None
+stream_monitor: RequestorStreamMonitor | None = None
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -26,9 +28,15 @@ async def lifespan(app: FastAPI):
         logger.error(f"Failed to initialize database during startup: {e}")
         # Depending on requirements, you might want to prevent the app from starting
         # raise RuntimeError(f"Database initialization failed: {e}") from e
+    # Start requestor stream monitor
+    global stream_monitor
+    stream_monitor = RequestorStreamMonitor(db_service)
+    stream_monitor.start()
     yield
     # Shutdown: Cleanup (if needed)
     logger.info("Shutting down API.")
+    if stream_monitor:
+        await stream_monitor.stop()
     # No explicit cleanup needed for aiosqlite connection usually
 
 app = FastAPI(lifespan=lifespan)
@@ -56,4 +64,4 @@ async def list_vms():
 # Example of another endpoint (can be removed if not needed)
 @app.get("/")
 async def read_root():
-    return {"message": "Golem Requestor API"}
+    return {"message": "Golem Requestor API"}

requestor/cli/commands.py

@@ -101,11 +101,13 @@ def vm():
 @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('--payments-network', type=str, default=None, help='Filter by payments network profile (default: current config)')
+@click.option('--all-payments', is_flag=True, help='Do not filter by payments network (show all)')
 @click.option('--json', 'as_json', is_flag=True, help='Output in JSON format')
 @click.option('--network', type=click.Choice(['testnet', 'mainnet']), default=None,
               help='Override network filter for this command')
 @async_command
-async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Optional[int], country: Optional[str], driver: Optional[str], as_json: bool, network: Optional[str] = None):
+async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Optional[int], country: Optional[str], driver: Optional[str], payments_network: Optional[str] = None, all_payments: bool = False, as_json: bool = False, network: Optional[str] = None):
     """List available providers matching requirements."""
     try:
         if network:
@@ -124,7 +126,8 @@ async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Opt
 
         # Determine the discovery driver being used
         discovery_driver = driver or config.discovery_driver
-        logger.process(f"Querying discovery service via {discovery_driver} (network={config.network})")
+        eff_pn = payments_network if payments_network is not None else getattr(config, 'payments_network', None)
+        logger.process(f"Querying discovery via {discovery_driver} (network={config.network}, payments={eff_pn if not all_payments else 'ALL'})")
 
         # Initialize provider service
         provider_service = ProviderService()
@@ -132,13 +135,21 @@ async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Opt
             # 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,
-                storage=storage,
-                country=country,
-                driver=driver
-            )
+            try:
+                providers = await provider_service.find_providers(
+                    cpu=cpu,
+                    memory=memory,
+                    storage=storage,
+                    country=country,
+                    driver=driver,
+                    payments_network=eff_pn,
+                    include_all_payments=bool(all_payments),
+                )
+            except TypeError:
+                # Backward compatibility with older/dummy service stubs in tests
+                providers = await provider_service.find_providers(
+                    cpu=cpu, memory=memory, storage=storage, country=country, driver=driver
+                )
 
         if not providers:
             logger.warning("No providers found matching criteria")
@@ -606,6 +617,10 @@ def wallet():
 async def wallet_faucet():
     """Request L2 faucet funds for the requestor's payment address."""
     try:
+        if not getattr(config, 'faucet_enabled', False):
+            logger.warning("Faucet is disabled for the current payments network.")
+            click.echo(json.dumps({"error": "faucet_disabled", "network": getattr(config, 'payments_network', None)}, indent=2))
+            return
         from ..security.faucet import L2FaucetService
         from eth_account import Account
         acct = Account.from_key(config.ethereum_private_key)
@@ -743,7 +758,16 @@ async def destroy_vm(name: str):
         # Initialize VM service
         provider_url = config.get_provider_url(vm['provider_ip'])
         async with ProviderClient(provider_url) as client:
-            vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client)
+            # Initialize blockchain client for stream termination on destroy
+            from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
+            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_client = StreamPaymentClient(spc)
+            vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client, sp_client)
             await vm_service.destroy_vm(name)
         
         # Show fancy success message
@@ -798,7 +822,16 @@ async def purge_vms(force: bool):
                 provider_url = config.get_provider_url(vm['provider_ip'])
                 
                 async with ProviderClient(provider_url) as client:
-                    vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client)
+                    # Initialize blockchain client for stream termination on purge
+                    from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
+                    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_client = StreamPaymentClient(spc)
+                    vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client, sp_client)
                     await vm_service.destroy_vm(vm['name'])
                     results['success'].append((vm['name'], 'Destroyed successfully'))
 
@@ -921,7 +954,16 @@ async def stop_vm(name: str):
         # Initialize VM service
         provider_url = config.get_provider_url(vm['provider_ip'])
         async with ProviderClient(provider_url) as client:
-            vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client)
+            # Initialize blockchain client for stream termination on stop
+            from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
+            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_client = StreamPaymentClient(spc)
+            vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client, sp_client)
             await vm_service.stop_vm(name)
 
         # Show fancy success message

requestor/config.py

@@ -54,6 +54,13 @@ class RequestorConfig(BaseSettings):
         description="Target network: 'testnet' or 'mainnet'"
     )
     
+    # Payments chain selection (modular network profiles)
+    # Keep current standard as l2.holesky
+    payments_network: str = Field(
+        default="l2.holesky",
+        description="Payments network profile (e.g., 'l2.holesky', 'kaolin.holesky', 'mainnet')"
+    )
+    
     # Development Settings
     force_localhost: bool = Field(
         default=False,
@@ -102,8 +109,8 @@ class RequestorConfig(BaseSettings):
     
     # Payments (EVM RPC)
     polygon_rpc_url: str = Field(
-        default="https://l2.holesky.golemdb.io/rpc",
-        description="EVM RPC URL for streaming payments (L2 by default)"
+        default="",
+        description="EVM RPC URL for streaming payments; defaults from payments_network profile"
     )
     stream_payment_address: str = Field(
         default="",
@@ -113,10 +120,27 @@ class RequestorConfig(BaseSettings):
         default="",
         description="Token address (0x0 means native ETH). Defaults from l2.json"
     )
-    # Faucet settings (L2 payments)
+    # Stream monitor (auto top-up)
+    stream_monitor_enabled: bool = Field(
+        default=True,
+        description="Enable background monitor to auto top-up streams"
+    )
+    stream_monitor_interval_seconds: int = Field(
+        default=30,
+        description="How frequently to check and top up streams"
+    )
+    stream_min_remaining_seconds: int = Field(
+        default=3600,
+        description="Minimum remaining runway to maintain (seconds)"
+    )
+    stream_topup_target_seconds: int = Field(
+        default=3600,
+        description="Target runway after top-up (seconds)"
+    )
+    # Faucet settings (payments)
     l2_faucet_url: str = Field(
-        default="https://l2.holesky.golemdb.io/faucet",
-        description="L2 faucet base URL (no trailing /api)"
+        default="",
+        description="Faucet base URL (no trailing /api). Only used on testnets. Defaults from payments_network profile"
     )
     captcha_url: str = Field(
         default="https://cap.gobas.me",
@@ -133,8 +157,8 @@ class RequestorConfig(BaseSettings):
 
     @field_validator("polygon_rpc_url", mode='before')
     @classmethod
-    def prefer_alt_env(cls, v: str) -> str:
-        # Accept alt aliases
+    def prefer_alt_env(cls, v: str, info: ValidationInfo) -> str:
+        # Accept alt aliases overriding the profile
         for key in (
             "GOLEM_REQUESTOR_l2_rpc_url",
             "GOLEM_REQUESTOR_L2_RPC_URL",
@@ -143,22 +167,45 @@ class RequestorConfig(BaseSettings):
         ):
             if os.environ.get(key):
                 return os.environ[key]
-        return v
+        if v:
+            return v
+        # Default from payments profile
+        pn = info.data.get("payments_network") or "l2.holesky"
+        return RequestorConfig._profile_defaults(pn)["rpc_url"]
+
+    @field_validator("l2_faucet_url", mode='before')
+    @classmethod
+    def default_faucet_env(cls, v: str, info: ValidationInfo) -> str:
+        for key in (
+            "GOLEM_REQUESTOR_l2_faucet_url",
+            "GOLEM_REQUESTOR_L2_FAUCET_URL",
+        ):
+            if os.environ.get(key):
+                return os.environ[key]
+        if v:
+            return v
+        pn = info.data.get("payments_network") or "l2.holesky"
+        return RequestorConfig._profile_defaults(pn).get("faucet_url", "")
 
     @staticmethod
-    def _load_l2_deployment() -> tuple[str | None, str | None]:
+    def _load_deployment(network: str) -> tuple[str | None, str | None]:
         try:
             base = os.environ.get("GOLEM_DEPLOYMENTS_DIR")
             if base:
-                path = Path(base) / "l2.json"
+                path = Path(base) / f"{RequestorConfig._deployment_basename(network)}.json"
             else:
                 # repo root assumption: ../../ relative to this file
-                path = Path(__file__).resolve().parents[2] / "contracts" / "deployments" / "l2.json"
+                path = (
+                    Path(__file__).resolve().parents[2]
+                    / "contracts" / "deployments" / f"{RequestorConfig._deployment_basename(network)}.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]
+                    with ir.files("requestor.data.deployments").joinpath(
+                        f"{RequestorConfig._deployment_basename(network)}.json"
+                    ).open("r") as fh:  # type: ignore[attr-defined]
                         import json as _json
                         data = _json.load(fh)
                 except Exception:
@@ -175,22 +222,83 @@ class RequestorConfig(BaseSettings):
             pass
         return None, None
 
+    @staticmethod
+    def _deployment_basename(network: str) -> str:
+        # Map well-known network aliases to deployment file base names
+        n = (network or "").lower()
+        if n in ("l2", "l2.holesky"):  # current standard
+            return "l2"
+        if "." in n:
+            return n.split(".")[0]
+        return n or "l2"
+
+    @staticmethod
+    def _profile_defaults(network: str) -> Dict[str, str]:
+        n = (network or "l2.holesky").lower()
+        # Built-in profiles; extend easily in future
+        profiles = {
+            "l2.holesky": {
+                "rpc_url": "https://l2.holesky.golemdb.io/rpc",
+                "faucet_url": "https://l2.holesky.golemdb.io/faucet",
+                "faucet_enabled": True,
+                "token_symbol": "GLM",
+                "gas_symbol": "ETH",
+            },
+            # Example: mainnet has no faucet by default
+            "mainnet": {
+                "rpc_url": "",
+                "faucet_url": "",
+                "faucet_enabled": False,
+                "token_symbol": "GLM",
+                "gas_symbol": "ETH",
+            },
+        }
+        return profiles.get(n, profiles["l2.holesky"])  # default to current standard
+
     @field_validator("stream_payment_address", mode='before')
     @classmethod
-    def default_stream_addr(cls, v: str) -> str:
+    def default_stream_addr(cls, v: str, info: ValidationInfo) -> str:
         if v:
             return v
-        addr, _ = RequestorConfig._load_l2_deployment()
+        network = info.data.get("payments_network") or "l2.holesky"
+        addr, _ = RequestorConfig._load_deployment(network)
         return addr or "0x0000000000000000000000000000000000000000"
 
     @field_validator("glm_token_address", mode='before')
     @classmethod
-    def default_token_addr(cls, v: str) -> str:
+    def default_token_addr(cls, v: str, info: ValidationInfo) -> str:
         if v:
             return v
-        _, token = RequestorConfig._load_l2_deployment()
+        network = info.data.get("payments_network") or "l2.holesky"
+        _, token = RequestorConfig._load_deployment(network)
         return token or "0x0000000000000000000000000000000000000000"
 
+    # Optional convenience: expose token and gas symbols based on profile
+    token_symbol: str = Field(
+        default="",
+        description="Human-friendly symbol of payment token (e.g., GLM)"
+    )
+    gas_token_symbol: str = Field(
+        default="",
+        description="Symbol of gas token for the chain (e.g., ETH)"
+    )
+
+    @field_validator("token_symbol", mode="before")
+    @classmethod
+    def default_token_symbol(cls, v: str, info: ValidationInfo) -> str:
+        if v:
+            return v
+        pn = info.data.get("payments_network") or "l2.holesky"
+        return RequestorConfig._profile_defaults(pn).get("token_symbol", "")
+
+    @field_validator("gas_token_symbol", mode="before")
+    @classmethod
+    def default_gas_symbol(cls, v: str, info: ValidationInfo) -> str:
+        if v:
+            return v
+        pn = info.data.get("payments_network") or "l2.holesky"
+        return RequestorConfig._profile_defaults(pn).get("gas_symbol", "")
+
     # Base Directory
     base_dir: Path = Field(
         default_factory=lambda: Path.home() / ".golem" / "requestor",
@@ -223,6 +331,11 @@ class RequestorConfig(BaseSettings):
             kwargs['db_path'] = base_dir / "vms.db"
         super().__init__(**kwargs)
 
+    @property
+    def faucet_enabled(self) -> bool:
+        """Whether requesting funds from faucet is allowed for current payments network."""
+        return bool(self._profile_defaults(self.payments_network).get("faucet_enabled", False))
+
     def get_provider_url(self, ip_address: str) -> str:
         """Get provider API URL.
         

requestor/payments/monitor.py

@@ -0,0 +1,126 @@
+import asyncio
+from typing import Optional
+
+from ..services.database_service import DatabaseService
+from ..provider.client import ProviderClient
+from ..config import config
+from ..utils.logging import setup_logger
+from .blockchain_service import StreamPaymentClient, StreamPaymentConfig
+
+
+class RequestorStreamMonitor:
+    def __init__(self, db: DatabaseService):
+        self.db = db
+        self._task: Optional[asyncio.Task] = None
+        self._logger = setup_logger(__name__)
+        self._sp = StreamPaymentClient(
+            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,
+            )
+        )
+
+    def start(self):
+        if not config.stream_monitor_enabled:
+            return
+        self._logger.info(
+            f"⏱️ Requestor stream auto-topup enabled interval={config.stream_monitor_interval_seconds}s "
+            f"min_remaining={config.stream_min_remaining_seconds}s target={config.stream_topup_target_seconds}s"
+        )
+        self._task = asyncio.create_task(self._run(), name="requestor-stream-monitor")
+
+    async def stop(self):
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            self._logger.info("Requestor stream auto-topup stopped")
+
+    async def _resolve_stream_id(self, vm: dict) -> Optional[int]:
+        # Prefer local DB recorded stream_id
+        sid = vm.get("config", {}).get("stream_id")
+        if isinstance(sid, int):
+            return sid
+        # Ask provider for mapping
+        try:
+            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"])
+                sid = status.get("stream_id")
+                self._logger.debug(f"Resolved stream for VM {vm['name']}: {sid}")
+                return int(sid) if sid is not None else None
+        except Exception as e:
+            self._logger.debug(f"Could not resolve stream for VM {vm['name']}: {e}")
+            return None
+
+    async def _run(self):
+        interval = max(int(config.stream_monitor_interval_seconds), 5)
+        min_remaining = max(int(config.stream_min_remaining_seconds), 0)
+        target_seconds = max(int(config.stream_topup_target_seconds), min_remaining)
+        while True:
+            try:
+                vms = await self.db.list_vms()
+                self._logger.debug(f"stream monitor tick: {len(vms)} VMs to check")
+                for vm in vms:
+                    # Only manage running VMs
+                    if vm.get("status") != "running":
+                        self._logger.debug(f"skip VM {vm.get('name')} status={vm.get('status')}")
+                        continue
+                    stream_id = await self._resolve_stream_id(vm)
+                    if stream_id is None:
+                        self._logger.debug(f"skip VM {vm.get('name')} no stream mapped")
+                        continue
+                    # Read on-chain stream tuple via contract
+                    try:
+                        token, sender, recipient, startTime, stopTime, ratePerSecond, deposit, withdrawn, halted = (
+                            self._sp.contract.functions.streams(int(stream_id)).call()
+                        )
+                    except Exception as e:
+                        self._logger.warning(f"stream lookup failed for {stream_id}: {e}")
+                        continue
+                    if bool(halted):
+                        # Respect terminated streams
+                        self._logger.debug(f"skip stream {stream_id} halted=true")
+                        continue
+                    # Compute remaining seconds using chain time
+                    try:
+                        now = int(self._sp.web3.eth.get_block("latest")["timestamp"])
+                    except Exception as e:
+                        self._logger.warning(f"could not get chain time: {e}")
+                        continue
+                    remaining = max(int(stopTime) - now, 0)
+                    self._logger.debug(
+                        f"VM {vm.get('name')} stream {stream_id}: remaining={remaining}s rate={int(ratePerSecond)}"
+                    )
+                    if remaining < min_remaining:
+                        # Top up to reach target_seconds of runway
+                        deficit = max(target_seconds - remaining, 0)
+                        add_wei = int(deficit) * int(ratePerSecond)
+                        if add_wei <= 0:
+                            continue
+                        try:
+                            self._logger.info(
+                                f"⛽ topping up stream {stream_id} by {add_wei} wei to reach {target_seconds}s"
+                            )
+                            self._sp.top_up(int(stream_id), int(add_wei))
+                            self._logger.success(
+                                f"topped up stream {stream_id} (+{add_wei} wei); VM={vm.get('name')}"
+                            )
+                        except Exception as e:
+                            # Ignore failures; will retry next tick
+                            self._logger.warning(f"top-up failed for stream {stream_id}: {e}")
+                    else:
+                        self._logger.debug(
+                            f"stream {stream_id} healthy (remaining={remaining}s >= {min_remaining}s)"
+                        )
+                await asyncio.sleep(interval)
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                # Keep the monitor resilient
+                self._logger.error(f"requestor stream monitor error: {e}")
+                await asyncio.sleep(interval)

requestor/security/faucet.py

@@ -15,7 +15,7 @@ class L2FaucetService:
         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'),
+            faucet_url=getattr(config, 'l2_faucet_url', '') or 'https://l2.holesky.golemdb.io/faucet',
             captcha_base_url=getattr(config, 'captcha_url', 'https://cap.gobas.me'),
             captcha_api_key=getattr(config, 'captcha_api_key', '05381a2cef5e'),
         )
@@ -29,6 +29,10 @@ class L2FaucetService:
             return 0.0
 
     async def request_funds(self, address: str) -> Optional[str]:
+        # Disallow faucet if explicitly disabled by profile
+        if hasattr(self.cfg, 'faucet_enabled') and not getattr(self.cfg, 'faucet_enabled'):
+            logger.info("Faucet disabled for current payments network; skipping.")
+            return None
         bal = self._balance_eth(address)
         if bal > 0.01:
             logger.info(f"Sufficient L2 funds ({bal} ETH), skipping faucet.")
@@ -51,4 +55,3 @@ class L2FaucetService:
         if tx:
             logger.success(f"L2 faucet sent tx: {tx}")
         return tx
-

requestor/services/provider_service.py

@@ -66,7 +66,9 @@ class ProviderService:
         memory: Optional[int] = None,
         storage: Optional[int] = None,
         country: Optional[str] = None,
-        driver: Optional[str] = None
+        driver: Optional[str] = None,
+        payments_network: Optional[str] = None,
+        include_all_payments: bool = False,
     ) -> List[Dict]:
         """Find providers matching requirements."""
         discovery_driver = driver or config.discovery_driver
@@ -79,7 +81,11 @@ class ProviderService:
                     ws_url=config.golem_base_ws_url,
                     private_key=private_key_bytes,
                 )
-            return await self._find_providers_golem_base(cpu, memory, storage, country)
+            return await self._find_providers_golem_base(
+                cpu, memory, storage, country,
+                payments_network=payments_network,
+                include_all_payments=include_all_payments,
+            )
         else:
             return await self._find_providers_central(cpu, memory, storage, country)
 
@@ -88,7 +94,9 @@ class ProviderService:
         cpu: Optional[int] = None,
         memory: Optional[int] = None,
         storage: Optional[int] = None,
-        country: Optional[str] = None
+        country: Optional[str] = None,
+        payments_network: Optional[str] = None,
+        include_all_payments: bool = False,
     ) -> List[Dict]:
         """Find providers using Golem Base."""
         try:
@@ -104,6 +112,10 @@ class ProviderService:
             # Filter by advertised network to avoid cross-network results
             if config.network:
                 query += f' && golem_network="{config.network}"'
+            # Filter by payments network unless explicitly disabled
+            pn = payments_network if payments_network is not None else getattr(config, 'payments_network', None)
+            if pn and not include_all_payments:
+                query += f' && golem_payments_network="{pn}"'
             if cpu:
                 query += f' && golem_cpu>={cpu}'
             if memory:
@@ -130,6 +142,7 @@ class ProviderService:
                     'provider_name': annotations.get('golem_provider_name'),
                     'ip_address': annotations.get('golem_ip_address'),
                     'country': annotations.get('golem_country'),
+                    'payments_network': annotations.get('golem_payments_network'),
                     'resources': {
                         'cpu': int(annotations.get('golem_cpu', 0)),
                         'memory': int(annotations.get('golem_memory', 0)),

requestor/services/vm_service.py

@@ -142,11 +142,11 @@ class VMService:
             # Update status in database
             await self.db.update_vm_status(name, "stopped")
 
-            # Best-effort withdraw on stop
+            # Best-effort terminate stream on stop (treat stop as end of agreement)
             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)
+                    self.blockchain_client.terminate(stream_id)
             except Exception:
                 pass