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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: request-vm-on-golem
-Version: 0.1.41
+Version: 0.1.44
 Summary: VM on Golem Requestor CLI - Create and manage virtual machines on the Golem Network
 Keywords: golem,vm,cloud,decentralized,cli
 Author: Phillip Jensen
@@ -25,6 +25,8 @@ Requires-Dist: colorlog (>=6.8.0,<7.0.0)
 Requires-Dist: cryptography (>=3.4.7,<4.0.0)
 Requires-Dist: fastapi (>=0.103.0,<0.104.0)
 Requires-Dist: golem-base-sdk (==0.1.0)
+Requires-Dist: golem-faucet (>=0.1.0,<0.2.0)
+Requires-Dist: golem-streaming-abi (>=0.1.0,<0.2.0)
 Requires-Dist: httptools (>=0.6.0,<0.7.0)
 Requires-Dist: pydantic (>=2.4.0,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
@@ -119,17 +121,17 @@ The SSH connection process:
 2. The provider's proxy system forwards your SSH connection to the VM
 3. All traffic is securely routed through the allocated port
 
-## Streaming Payments (Polygon GLM)
+## Streaming Payments (Native ETH on L2)
 
-This requestor integrates with an on‑chain StreamPayment contract to enable “pay‑as‑you‑go” rentals.
+This requestor integrates with an on‑chain StreamPayment contract to enable “pay‑as‑you‑go” rentals using native ETH (no ERC20 approvals when the token address is zero).
 
 Flow:
 
-1. Fetch provider info:
-   - `GET http://{provider}:7466/api/v1/provider/info` → `provider_id`, `stream_payment_address`, `glm_token_address`.
+1. Fetch provider info (preferred addresses):
+   - `GET http://{provider}:7466/api/v1/provider/info` → `provider_id`, `stream_payment_address`, `glm_token_address` (zero address means native ETH).
 2. Compute `ratePerSecond` from provider pricing and requested VM resources.
 3. Ensure `deposit >= ratePerSecond * 3600` (≥ 1 hour runway recommended/minimum).
-4. Create a stream (approve + `createStream(GLM, provider_id, deposit, ratePerSecond)`), capture `stream_id`.
+4. Create a stream (`createStream(0x000...0, provider_id, deposit, ratePerSecond)` plus `value=deposit`), capture `stream_id`. For ERC20 mode use a token address and approve first.
 5. Create VM: `POST /api/v1/vms` with `stream_id` included.
 6. Top‑up over time with `topUp(stream_id, amount)` to extend stopTime and keep the VM running indefinitely.
 7. On stop/destroy: the requestor will best‑effort `withdraw` / `terminate` to settle.
@@ -156,7 +158,7 @@ poetry run golem vm stream topup --stream-id 123 --hours 3
 poetry run golem vm stream topup --stream-id 123 --glm 25.0
 ```
 
-- Create a VM and attach an existing stream:
+- Create a VM and attach an existing stream (no auto-streams are created by the requestor):
 
 ```bash
 poetry run golem vm create my-vm \
@@ -167,15 +169,30 @@ poetry run golem vm create my-vm \
 
 Environment (env prefix `GOLEM_REQUESTOR_`):
 
-- `polygon_rpc_url` — Polygon PoS RPC URL
-- `stream_payment_address` — StreamPayment address
-- `glm_token_address` — GLM ERC20 address
-- `provider_eth_address` — optional helper for development; in production always use `/provider/info`
+- `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
+- `provider_eth_address` — optional dev helper; in production always use `/provider/info`
+- `network` — Target network for discovery filtering: `testnet` (default) or `mainnet`
 
 Efficiency tips:
 
 - Batch top‑ups (e.g., add several hours at once) to reduce on‑chain calls.
 - Withdrawals are typically executed by providers; requestors don’t need to withdraw.
+- The CLI `vm stream open` will prefer the provider’s advertised contract/token addresses to prevent mismatches.
+
+## Faucet (L2 ETH)
+
+- Request L2 test ETH to cover stream transactions:
+
+```bash
+poetry run golem wallet faucet
+```
+
+- Defaults:
+  - Faucet: `https://l2.holesky.golemdb.io/faucet`
+  - CAPTCHA: `https://cap.gobas.me/05381a2cef5e`
+  - Override with env: `GOLEM_REQUESTOR_l2_faucet_url`, `GOLEM_REQUESTOR_captcha_url`, `GOLEM_REQUESTOR_captcha_api_key`.
 
 ## Installation
 
@@ -217,6 +234,27 @@ Alternatively, you can prepend the environment variables directly to the command
 GOLEM_REQUESTOR_ENVIRONMENT="development" GOLEM_REQUESTOR_FORCE_LOCALHOST="true" poetry run golem vm providers
 ```
 
+### Mode vs. Network
+
+- Development Mode (`GOLEM_REQUESTOR_ENVIRONMENT=development`)
+  - Improves local workflows: prefixes central discovery URL with `DEVMODE-` and, when using the central driver, maps provider IPs to `localhost` for easier testing.
+  - 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.
+
+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
+  ```
+
 ## Usage
 
 ### Provider Discovery
@@ -334,6 +372,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
 ```
 
 2. Directory Structure:

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

@@ -1,25 +1,26 @@
 requestor/__init__.py,sha256=OqSUAh1uZBMx7GW0MoSMg967PVdmT8XdPJx3QYjwkak,116
 requestor/api/main.py,sha256=7utCzFNbh5Ol-vsBWeSwT4lXeHD7zdA-GFZuS3rHMWc,2180
 requestor/cli/__init__.py,sha256=e3E4oEGxmGj-STPtFkQwg_qIWhR0JAiAQdw3G1hXciU,37
-requestor/cli/commands.py,sha256=b9_Vy30rf3hpoBb_9Gu9z4mPWF3_oBjUjd-5pX2bVvU,33277
-requestor/config.py,sha256=suWN2-4AL0Pphu2t-_WiTKIFG-0_cJjWwR_CIOW1c24,5320
+requestor/cli/commands.py,sha256=YiJvCWDp__c8OZ1YdrVc7gAYRUab5ygNGPCGxDmn3jE,35288
+requestor/config.py,sha256=v6557eetioJmuOPWKV4iAl7DeqGjgQ0gegqc0zEzJZU,6396
 requestor/db/__init__.py,sha256=Gm5DfWls6uvCZZ3HGGnyRHswbUQdeA5OGN8yPwH0hc8,88
 requestor/db/sqlite.py,sha256=l5pWbx2qlHuar1N_a0B9tVnmumLJY1w5rp3yZ7jmsC0,4146
 requestor/errors.py,sha256=wVpHBuYgQx5pTe_SamugfK-k768noikY1RxvPOjQGko,665
-requestor/payments/blockchain_service.py,sha256=w9ONdKVf2E7BCEgDRiTeEqwdNTr8SqZiXHKdV5JH2ZQ,5757
+requestor/payments/blockchain_service.py,sha256=EejW51A6Xqc3PKnKnzjRQ6pIVkH1FqacG4lwQAQ0HiM,6888
 requestor/provider/__init__.py,sha256=fmW23aYUVciF8-gmBZkG-PLhn22upmcDzdPfAOLHG6g,103
 requestor/provider/client.py,sha256=WXCm-1bytcgsuHEZzpg7RjjDOTuaXC9cj0Mrm7e6DSw,3676
 requestor/run.py,sha256=GqOG6n34szt8Sp3SEqjRV6huWm737yCN6YnBqoiwI-U,1785
+requestor/security/faucet.py,sha256=35d8mD3fM0YqRIhUXuIKandOL8vbw2T2IFQWVsan9Lw,2056
 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=auUc5XSHWbtOzyLHFqJ4RF337rCNYThzb7TjvUaK_uo,14542
+requestor/services/provider_service.py,sha256=SH76qxnbIm4EgCwQ0SHiwCidN19aTQMCxGUj1e0yGRQ,14712
 requestor/services/ssh_service.py,sha256=tcOCtk2SlB9Uuv-P2ghR22e7BJ9kigQh5b4zSGdPFns,4280
-requestor/services/vm_service.py,sha256=UPPj7aD0b7nCyNH6I-b35xdsqAkRUiQlpQBVGK4B7ms,8858
+requestor/services/vm_service.py,sha256=eQ2pPMpYlfPVbVFrkFElsRO5swPq-2XZEfuvxagyHDk,7941
 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.41.dist-info/METADATA,sha256=znwTKJHh21R9DsDgeHeaKFwxZFFC95vOTj-kScsc2Tc,11924
-request_vm_on_golem-0.1.41.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-request_vm_on_golem-0.1.41.dist-info/entry_points.txt,sha256=Z-skRNpJ8aZcIl_En9mEm1ygkp9FKy0bzQoL3zO52-0,44
-request_vm_on_golem-0.1.41.dist-info/RECORD,,
+request_vm_on_golem-0.1.44.dist-info/METADATA,sha256=oNqjV3CuQMnhZA1SRGPBf9M8J_-J8WsVBaSOdJnrxKE,13912
+request_vm_on_golem-0.1.44.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+request_vm_on_golem-0.1.44.dist-info/entry_points.txt,sha256=Z-skRNpJ8aZcIl_En9mEm1ygkp9FKy0bzQoL3zO52-0,44
+request_vm_on_golem-0.1.44.dist-info/RECORD,,

requestor/cli/commands.py

@@ -75,9 +75,17 @@ def print_version(ctx, param, value):
 @click.group()
 @click.option('--version', is_flag=True, callback=print_version,
               expose_value=False, is_eager=True, help="Show the version and exit.")
-def cli():
+@click.option('--network', type=click.Choice(['testnet', 'mainnet']), default=None,
+              help="Override network for discovery filtering ('testnet' or 'mainnet')")
+def cli(network: str | None):
     """VM on Golem management CLI"""
     ensure_config()
+    # Allow on-demand override without touching env
+    if network:
+        try:
+            config.network = network
+        except Exception:
+            pass
     pass
 
 
@@ -94,10 +102,14 @@ def vm():
 @click.option('--country', help='Preferred provider country')
 @click.option('--driver', type=click.Choice(['central', 'golem-base']), default=None, help='Discovery driver to use')
 @click.option('--json', 'as_json', is_flag=True, help='Output in JSON format')
+@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):
+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):
     """List available providers matching requirements."""
     try:
+        if network:
+            config.network = network
         # Log search criteria if any
         if any([cpu, memory, storage, country]):
             logger.command("🔍 Searching for providers with criteria:")
@@ -112,7 +124,7 @@ 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}")
+        logger.process(f"Querying discovery service via {discovery_driver} (network={config.network})")
 
         # Initialize provider service
         provider_service = ProviderService()
@@ -175,10 +187,13 @@ async def list_providers(cpu: Optional[int], memory: Optional[int], storage: Opt
 @click.option('--storage', type=int, required=True, help='Disk in GB')
 @click.option('--stream-id', type=int, default=None, help='Optional StreamPayment stream id to fund this VM')
 @click.option('--yes', is_flag=True, help='Do not prompt for confirmation')
+@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):
+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):
     """Create a new VM on a specific provider."""
     try:
+        if network:
+            config.network = network
         # Show configuration details
         click.echo("\n" + "─" * 60)
         click.echo(click.style("  VM Configuration", fg="blue", bold=True))
@@ -295,11 +310,14 @@ def vm_stream():
 @click.option('--memory', type=int, required=True, help='Memory (GB) for rate calc')
 @click.option('--storage', type=int, required=True, help='Storage (GB) for rate calc')
 @click.option('--hours', type=int, default=1, help='Deposit coverage in hours (default 1)')
+@click.option('--network', type=click.Choice(['testnet', 'mainnet']), default=None, help='Override network for discovery during stream open')
 @async_command
-async def stream_open(provider_id: str, cpu: int, memory: int, storage: int, hours: int):
+async def stream_open(provider_id: str, cpu: int, memory: int, storage: int, hours: int, network: Optional[str] = None):
     """Create a GLM stream for a planned VM rental."""
     from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
     try:
+        if network:
+            config.network = network
         provider_service = ProviderService()
         async with provider_service:
             provider = await provider_service.verify_provider(provider_id)
@@ -319,10 +337,11 @@ async def stream_open(provider_id: str, cpu: int, memory: int, storage: int, hou
                 recipient = info['provider_id']
 
             deposit_wei = rate_per_second_wei * int(hours) * 3600
+            # Prefer provider-advertised contract addresses to avoid mismatches
             spc = StreamPaymentConfig(
                 rpc_url=config.polygon_rpc_url,
-                contract_address=config.stream_payment_address,
-                glm_token_address=config.glm_token_address,
+                contract_address=info.get('stream_payment_address') or config.stream_payment_address,
+                glm_token_address=info.get('glm_token_address') or config.glm_token_address,
                 private_key=config.ethereum_private_key,
             )
             sp = StreamPaymentClient(spc)
@@ -365,6 +384,31 @@ async def stream_topup(stream_id: int, glm: float | None, hours: int | None):
         raise click.Abort()
 
 
+@cli.group()
+def wallet():
+    """Wallet utilities (funding, balance)."""
+    pass
+
+
+@wallet.command('faucet')
+@async_command
+async def wallet_faucet():
+    """Request L2 faucet funds for the requestor's payment address."""
+    try:
+        from ..security.faucet import L2FaucetService
+        from eth_account import Account
+        acct = Account.from_key(config.ethereum_private_key)
+        service = L2FaucetService(config)
+        tx = await service.request_funds(acct.address)
+        if tx:
+            click.echo(json.dumps({"address": acct.address, "tx": tx}, indent=2))
+        else:
+            click.echo(json.dumps({"address": acct.address, "tx": None}, indent=2))
+    except Exception as e:
+        logger.error(f"Faucet request failed: {e}")
+        raise click.Abort()
+
+
 @vm.command(name='ssh')
 @click.argument('name')
 @async_command

requestor/config.py

@@ -3,6 +3,7 @@ from typing import Optional, Dict
 import os
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from pydantic import Field, field_validator, ValidationInfo
+import os
 
 
 def ensure_config() -> None:
@@ -47,6 +48,11 @@ class RequestorConfig(BaseSettings):
         default="production",
         description="Environment mode: 'development' or 'production'"
     )
+    # Network (for discovery filtering and defaults)
+    network: str = Field(
+        default="mainnet",
+        description="Target network: 'testnet' or 'mainnet'"
+    )
     
     # Development Settings
     force_localhost: bool = Field(
@@ -94,10 +100,10 @@ class RequestorConfig(BaseSettings):
         description="Private key for Golem Base"
     )
     
-    # Polygon / Payments
+    # Payments (EVM RPC)
     polygon_rpc_url: str = Field(
-        default="https://polygon-rpc.com",
-        description="Polygon PoS RPC URL for GLM payments"
+        default="https://l2.holesky.golemdb.io/rpc",
+        description="EVM RPC URL for streaming payments (L2 by default)"
     )
     stream_payment_address: str = Field(
         default="0x0000000000000000000000000000000000000000",
@@ -105,13 +111,40 @@ class RequestorConfig(BaseSettings):
     )
     glm_token_address: str = Field(
         default="0x0000000000000000000000000000000000000000",
-        description="GLM ERC20 token address on target network"
+        description="Token address (0x0 means native ETH)"
+    )
+    # Faucet settings (L2 payments)
+    l2_faucet_url: str = Field(
+        default="https://l2.holesky.golemdb.io/faucet",
+        description="L2 faucet base URL (no trailing /api)"
+    )
+    captcha_url: str = Field(
+        default="https://cap.gobas.me",
+        description="CAPTCHA base URL"
+    )
+    captcha_api_key: str = Field(
+        default="05381a2cef5e",
+        description="CAPTCHA API key path segment"
     )
     provider_eth_address: str = Field(
         default="",
         description="Optional provider Ethereum address for test/dev streaming"
     )
 
+    @field_validator("polygon_rpc_url", mode='before')
+    @classmethod
+    def prefer_alt_env(cls, v: str) -> str:
+        # Accept alt aliases
+        for key in (
+            "GOLEM_REQUESTOR_l2_rpc_url",
+            "GOLEM_REQUESTOR_L2_RPC_URL",
+            "GOLEM_REQUESTOR_kaolin_rpc_url",
+            "GOLEM_REQUESTOR_KAOLIN_RPC_URL",
+        ):
+            if os.environ.get(key):
+                return os.environ[key]
+        return v
+
     # Base Directory
     base_dir: Path = Field(
         default_factory=lambda: Path.home() / ".golem" / "requestor",

requestor/payments/blockchain_service.py

@@ -5,64 +5,7 @@ from typing import Optional, Any, Dict
 
 from web3 import Web3
 from eth_account import Account
-
-
-STREAM_PAYMENT_ABI = [
-    {
-        "inputs": [
-            {"internalType": "address", "name": "token", "type": "address"},
-            {"internalType": "address", "name": "recipient", "type": "address"},
-            {"internalType": "uint256", "name": "deposit", "type": "uint256"},
-            {"internalType": "uint128", "name": "ratePerSecond", "type": "uint128"},
-        ],
-        "name": "createStream",
-        "outputs": [{"internalType": "uint256", "name": "streamId", "type": "uint256"}],
-        "stateMutability": "nonpayable",
-        "type": "function",
-    },
-    {
-        "inputs": [{"internalType": "uint256", "name": "streamId", "type": "uint256"}],
-        "name": "withdraw",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function",
-    },
-    {
-        "inputs": [{"internalType": "uint256", "name": "streamId", "type": "uint256"}],
-        "name": "terminate",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function",
-    },
-    {
-        "anonymous": False,
-        "inputs": [
-            {"indexed": True, "internalType": "uint256", "name": "streamId", "type": "uint256"},
-            {"indexed": True, "internalType": "address", "name": "sender", "type": "address"},
-            {"indexed": True, "internalType": "address", "name": "recipient", "type": "address"},
-            {"indexed": False, "internalType": "address", "name": "token", "type": "address"},
-            {"indexed": False, "internalType": "uint256", "name": "deposit", "type": "uint256"},
-            {"indexed": False, "internalType": "uint256", "name": "ratePerSecond", "type": "uint256"},
-            {"indexed": False, "internalType": "uint256", "name": "startTime", "type": "uint256"},
-            {"indexed": False, "internalType": "uint256", "name": "stopTime", "type": "uint256"},
-        ],
-        "name": "StreamCreated",
-        "type": "event",
-    },
-]
-
-ERC20_ABI = [
-    {
-        "name": "approve",
-        "type": "function",
-        "stateMutability": "nonpayable",
-        "inputs": [
-            {"name": "spender", "type": "address"},
-            {"name": "amount", "type": "uint256"},
-        ],
-        "outputs": [{"name": "", "type": "bool"}],
-    }
-]
+from golem_streaming_abi import STREAM_PAYMENT_ABI, ERC20_ABI
 
 
 @dataclass
@@ -82,17 +25,44 @@ class StreamPaymentClient:
         self.contract = self.web3.eth.contract(
             address=Web3.to_checksum_address(cfg.contract_address), abi=STREAM_PAYMENT_ABI
         )
-        self.erc20 = self.web3.eth.contract(
-            address=Web3.to_checksum_address(cfg.glm_token_address), abi=ERC20_ABI
-        )
+        self.token_address = Web3.to_checksum_address(cfg.glm_token_address)
+        self.native_eth = self.token_address.lower() == Web3.to_checksum_address("0x0000000000000000000000000000000000000000").lower()
+        self.erc20 = None
+        if not self.native_eth:
+            self.erc20 = self.web3.eth.contract(
+                address=self.token_address, abi=ERC20_ABI
+            )
 
     def _send(self, fn) -> Dict[str, Any]:
-        tx = fn.build_transaction(
-            {
-                "from": self.account.address,
-                "nonce": self.web3.eth.get_transaction_count(self.account.address),
-            }
-        )
+        base = {
+            "from": self.account.address,
+            "nonce": self.web3.eth.get_transaction_count(self.account.address),
+        }
+        # Fill chainId
+        try:
+            base["chainId"] = getattr(self.web3.eth, "chain_id", None) or self.web3.eth.chain_id
+        except Exception:
+            pass
+        # Try gas estimation and fee fields
+        try:
+            tx_preview = fn.build_transaction(base)
+            gas = self.web3.eth.estimate_gas(tx_preview)
+            base["gas"] = gas
+        except Exception:
+            pass
+        try:
+            # Prefer EIP-1559 if available
+            max_fee = getattr(self.web3.eth, "max_priority_fee", None)
+            if max_fee is not None:
+                base.setdefault("maxPriorityFeePerGas", max_fee)
+            base.setdefault("maxFeePerGas", getattr(self.web3.eth, "gas_price", lambda: None)() or self.web3.eth.gas_price)
+        except Exception:
+            try:
+                base.setdefault("gasPrice", self.web3.eth.gas_price)
+            except Exception:
+                pass
+
+        tx = fn.build_transaction(base)
         # In production, sign and send raw; in tests, Account may be a dummy without signer
         if hasattr(self.account, "sign_transaction"):
             signed = self.account.sign_transaction(tx)
@@ -103,22 +73,47 @@ class StreamPaymentClient:
         return {"transactionHash": tx_hash.hex(), "status": receipt.status, "logs": receipt.logs}
 
     def create_stream(self, provider_address: str, deposit_wei: int, rate_per_second_wei: int) -> int:
-        # 1) Approve deposit for the StreamPayment contract
-        approve = self.erc20.functions.approve(self.contract.address, int(deposit_wei))
-        self._send(approve)
+        tx_value = None
+        token_param = self.token_address if not self.native_eth else Web3.to_checksum_address("0x0000000000000000000000000000000000000000")
+
+        if not self.native_eth:
+            # Approve deposit for the StreamPayment contract (only if needed)
+            try:
+                allowance = self.erc20.functions.allowance(self.account.address, self.contract.address).call()
+            except Exception:
+                allowance = 0
+            if int(allowance) < int(deposit_wei):
+                approve = self.erc20.functions.approve(self.contract.address, int(deposit_wei))
+                self._send(approve)
+        else:
+            tx_value = int(deposit_wei)
 
-        # 2) Create stream
+        # Create stream
         fn = self.contract.functions.createStream(
-            self.erc20.address,
+            token_param,
             Web3.to_checksum_address(provider_address),
             int(deposit_wei),
             int(rate_per_second_wei),
         )
-        receipt = self._send(fn)
+        # Include ETH value if native
+        if tx_value is not None:
+            # Build/send with value field
+            base = {
+                "from": self.account.address,
+                "nonce": self.web3.eth.get_transaction_count(self.account.address),
+                "value": tx_value,
+            }
+            tx = fn.build_transaction(base)
+            signed = self.account.sign_transaction(tx)
+            tx_hash = self.web3.eth.send_raw_transaction(signed.rawTransaction)
+            receipt = self.web3.eth.wait_for_transaction_receipt(tx_hash)
+            tx_receipt = {"transactionHash": tx_hash.hex(), "status": receipt.status, "logs": receipt.logs}
+        else:
+            tx_receipt = self._send(fn)
 
         # Try to parse StreamCreated event for streamId
         try:
-            for log in receipt["logs"]:
+            for log in tx_receipt["logs"]:
                 # very naive filter: topic0 = keccak256(StreamCreated(...))
                 # When ABI is attached to contract, use contract.events
                 ev = self.contract.events.StreamCreated().process_log(log)
@@ -139,10 +134,28 @@ class StreamPaymentClient:
         return receipt["transactionHash"]
 
     def top_up(self, stream_id: int, amount_wei: int) -> str:
-        # Approve first
-        approve = self.erc20.functions.approve(self.contract.address, int(amount_wei))
-        self._send(approve)
-        # Top up
-        fn = self.contract.functions.topUp(int(stream_id), int(amount_wei))
-        receipt = self._send(fn)
-        return receipt["transactionHash"]
+        if not self.native_eth:
+            # Approve first (only if needed)
+            try:
+                allowance = self.erc20.functions.allowance(self.account.address, self.contract.address).call()
+            except Exception:
+                allowance = 0
+            if int(allowance) < int(amount_wei):
+                approve = self.erc20.functions.approve(self.contract.address, int(amount_wei))
+                self._send(approve)
+            fn = self.contract.functions.topUp(int(stream_id), int(amount_wei))
+            receipt = self._send(fn)
+            return receipt["transactionHash"]
+        else:
+            # Native ETH mode: send value along with call
+            fn = self.contract.functions.topUp(int(stream_id), int(amount_wei))
+            base = {
+                "from": self.account.address,
+                "nonce": self.web3.eth.get_transaction_count(self.account.address),
+                "value": int(amount_wei),
+            }
+            tx = fn.build_transaction(base)
+            signed = self.account.sign_transaction(tx)
+            tx_hash = self.web3.eth.send_raw_transaction(signed.rawTransaction)
+            self.web3.eth.wait_for_transaction_receipt(tx_hash)
+            return tx_hash.hex()

requestor/security/faucet.py

@@ -0,0 +1,54 @@
+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
+from ..config import RequestorConfig
+
+logger = setup_logger(__name__)
+
+
+class L2FaucetService:
+    def __init__(self, config: RequestorConfig):
+        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, 'captcha_url', 'https://cap.gobas.me'),
+            captcha_api_key=getattr(config, '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"balance check failed: {e}")
+            return 0.0
+
+    async def request_funds(self, address: str) -> Optional[str]:
+        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
+

requestor/services/provider_service.py

@@ -93,6 +93,9 @@ class ProviderService:
         """Find providers using Golem Base."""
         try:
             query = 'golem_type="provider"'
+            # Filter by advertised network to avoid cross-network results
+            if config.network:
+                query += f' && golem_network="{config.network}"'
             if cpu:
                 query += f' && golem_cpu>={cpu}'
             if memory:

requestor/services/vm_service.py

@@ -52,27 +52,8 @@ class VMService:
             # Get VM access info
             access_info = await self.provider_client.get_vm_access(vm['id'])
 
-            # Optionally create a GLM stream (if configured)
-            from ..config import config as app_config
-            stream_id = None
-            try:
-                if (
-                    self.blockchain_client
-                    and app_config.stream_payment_address != "0x0000000000000000000000000000000000000000"
-                    and app_config.glm_token_address != "0x0000000000000000000000000000000000000000"
-                    and app_config.provider_eth_address
-                ):
-                    # Simple heuristic: deposit for 1 hour at a nominal rate
-                    rate_per_second = 10**18  # 1 GLM / second (example)
-                    deposit = rate_per_second * 3600  # 1 hour worth
-                    stream_id = self.blockchain_client.create_stream(
-                        app_config.provider_eth_address,
-                        deposit,
-                        rate_per_second,
-                    )
-            except Exception:
-                # Do not fail VM creation if streaming setup fails
-                stream_id = None
+            # Preserve any provided stream_id; do not auto-create streams here
+            # Stream creation should be explicit via CLI `vm stream open` command.
 
             # Save VM details to database
             config = {