iwa 0.0.2__py3-none-any.whl → 0.0.11__py3-none-any.whl

iwa/plugins/olas/tests/test_service_manager.py

@@ -100,11 +100,6 @@ def mock_chain_interfaces():
         yield mock
 
 
-@pytest.fixture
-def mock_erc20_contract():
-    """Mock ERC20 contract fixture."""
-    with patch("iwa.plugins.olas.service_manager.staking.ERC20Contract") as mock:
-        yield mock
 
 
 @pytest.fixture
@@ -114,7 +109,7 @@ def service_manager(
     mock_registry,
     mock_manager_contract,
     mock_chain_interfaces,
-    mock_erc20_contract,
+
     mock_olas_config,
     mock_service,
 ):
@@ -174,12 +169,11 @@ def test_create_no_event(service_manager, mock_wallet):
     mock_wallet.sign_and_send_transaction.return_value = (True, {})
     service_manager.registry.extract_events.return_value = []
 
-    with patch("iwa.plugins.olas.service_manager.staking.ERC20Contract"):  # Mock ERC20
-        res = service_manager.create(
-            token_address_or_tag="0x1111111111111111111111111111111111111111"
-        )
-        # create() finds no ID, logs error, returns None for service_id.
-        assert res is None
+    res = service_manager.create(
+        token_address_or_tag="0x1111111111111111111111111111111111111111"
+    )
+    # create() finds no ID, logs error, returns None for service_id.
+    assert res is None
 
 
 def test_activate_registration_success(service_manager, mock_wallet):
@@ -193,7 +187,7 @@ def test_activate_registration_success(service_manager, mock_wallet):
 
     # Mock balance/allowance for the new check
     mock_wallet.balance_service = MagicMock()
-    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 10**18
+    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 100 * 10**18
     mock_wallet.transfer_service.get_erc20_allowance.return_value = 10**20
 
     assert service_manager.activate_registration() is True
@@ -287,18 +281,15 @@ def test_stake_success(service_manager, mock_wallet):
         "security_deposit": 50000000000000000000,
     }
 
-    with patch("iwa.plugins.olas.service_manager.staking.ERC20Contract") as mock_erc20:
-        mock_erc20.return_value.balance_of_wei.return_value = 100000000000000000000  # 100 OLAS
-
-        mock_wallet.sign_and_send_transaction.return_value = (True, {})
-        staking_contract.extract_events.return_value = [{"name": "ServiceStaked"}]
-        staking_contract.get_staking_state.return_value = StakingState.STAKED
+    mock_wallet.sign_and_send_transaction.return_value = (True, {})
+    staking_contract.extract_events.return_value = [{"name": "ServiceStaked"}]
+    staking_contract.get_staking_state.return_value = StakingState.STAKED
 
-        # We need to make sure prepare_approve_tx is mocked ON THE REGISTRY INSTANCE
-        service_manager.registry.prepare_approve_tx.return_value = {"to": "0xApprove"}
+    # We need to make sure prepare_approve_tx is mocked ON THE REGISTRY INSTANCE
+    service_manager.registry.prepare_approve_tx.return_value = {"to": "0xApprove"}
 
-        assert service_manager.stake(staking_contract) is True
-        assert service_manager.service.staking_contract_address == TEST_STAKING_ADDR
+    assert service_manager.stake(staking_contract) is True
+    assert service_manager.service.staking_contract_address == TEST_STAKING_ADDR
 
 
 def test_unstake_success(service_manager, mock_wallet):
@@ -370,60 +361,15 @@ def test_register_agent_fund_fails(service_manager, mock_wallet):
 
 def test_spin_up_from_pre_registration_success(service_manager, mock_wallet):
     """Test full spin_up path from PRE_REGISTRATION to DEPLOYED."""
-    # Mock state transitions - need to match actual calls in spin_up
-    # The state after activate_registration should be ACTIVE_REGISTRATION
-    state_sequence = [
-        {
-            "state": ServiceState.PRE_REGISTRATION,
-            "security_deposit": 50000000000000000000,
-        },  # spin_up initial
-        {
-            "state": ServiceState.PRE_REGISTRATION,
-            "security_deposit": 50000000000000000000,
-        },  # activate_registration check
-        {
-            "state": ServiceState.PRE_REGISTRATION,
-            "security_deposit": 50000000000000000000,
-        },  # activate_registration internal (get security deposit)
-        {
-            "state": ServiceState.ACTIVE_REGISTRATION,
-            "security_deposit": 50000000000000000000,
-        },  # spin_up verify after activate
-        {
-            "state": ServiceState.ACTIVE_REGISTRATION,
-            "security_deposit": 50000000000000000000,
-        },  # register_agent check
-        {
-            "state": ServiceState.ACTIVE_REGISTRATION,
-            "security_deposit": 50000000000000000000,
-        },  # register_agent internal
-        {
-            "state": ServiceState.FINISHED_REGISTRATION,
-            "security_deposit": 50000000000000000000,
-        },  # spin_up verify after register
-        {
-            "state": ServiceState.FINISHED_REGISTRATION,
-            "security_deposit": 50000000000000000000,
-        },  # deploy check
-        {
-            "state": ServiceState.DEPLOYED,
-            "security_deposit": 50000000000000000000,
-        },  # spin_up verify after deploy
-        {
-            "state": ServiceState.DEPLOYED,
-            "security_deposit": 50000000000000000000,
-        },  # final verification
+    # Use a stateful mock that progresses based on extract_events calls
+    states = [
+        ServiceState.PRE_REGISTRATION,  # Before any TX
+        ServiceState.ACTIVE_REGISTRATION,  # After 1st TX (activate)
+        ServiceState.FINISHED_REGISTRATION,  # After 2nd TX (register)
+        ServiceState.DEPLOYED,  # After 3rd TX (deploy)
     ]
-    service_manager.registry.get_service.side_effect = state_sequence
-
-    mock_wallet.send.return_value = "0xMockTxHash"  # wallet.send returns tx_hash
-    mock_wallet.sign_and_send_transaction.return_value = (True, {})
-
-    # Mock balance/allowance for activate_registration internal call
-    mock_wallet.balance_service = MagicMock()
-    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 10**18
-    mock_wallet.transfer_service.get_erc20_allowance.return_value = 10**20
-    service_manager.registry.extract_events.side_effect = [
+    tx_count = [0]  # Track completed transactions
+    events_side_effects = [
         [{"name": "ActivateRegistration"}],
         [{"name": "RegisterInstance"}],
         [
@@ -431,6 +377,32 @@ def test_spin_up_from_pre_registration_success(service_manager, mock_wallet):
             {"name": "CreateMultisigWithAgents", "args": {"multisig": TEST_MULTISIG_ADDR}},
         ],
     ]
+    event_idx = [0]
+
+    def dynamic_state(*args, **kwargs):
+        """Return state based on completed transactions."""
+        state = states[min(tx_count[0], len(states) - 1)]
+        return {"state": state, "security_deposit": 50000000000000000000}
+
+    def extract_and_progress(*args, **kwargs):
+        """Return events and advance transaction counter."""
+        if event_idx[0] < len(events_side_effects):
+            events = events_side_effects[event_idx[0]]
+            event_idx[0] += 1
+            tx_count[0] += 1
+            return events
+        return []
+
+    service_manager.registry.get_service.side_effect = dynamic_state
+    service_manager.registry.extract_events.side_effect = extract_and_progress
+
+    mock_wallet.send.return_value = "0xMockTxHash"
+    mock_wallet.sign_and_send_transaction.return_value = (True, {})
+
+    # Mock balance/allowance for activate_registration internal call
+    mock_wallet.balance_service = MagicMock()
+    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 100 * 10**18
+    mock_wallet.transfer_service.get_erc20_allowance.return_value = 10**20
 
     assert service_manager.spin_up() is True
 
@@ -557,14 +529,12 @@ def test_spin_up_with_staking(service_manager, mock_wallet):
         "required_agent_bond": 50000000000000000000,  # 50 OLAS
     }
 
-    with patch("iwa.plugins.olas.service_manager.staking.ERC20Contract") as mock_erc20:
-        mock_erc20.return_value.balance_of_wei.return_value = 100000000000000000000  # 100 OLAS
-        mock_wallet.sign_and_send_transaction.return_value = (True, {})
-        staking_contract.extract_events.return_value = [{"name": "ServiceStaked"}]
-        staking_contract.get_staking_state.return_value = StakingState.STAKED
-        service_manager.registry.prepare_approve_tx.return_value = {"to": "0xApprove"}
+    mock_wallet.sign_and_send_transaction.return_value = (True, {})
+    staking_contract.extract_events.return_value = [{"name": "ServiceStaked"}]
+    staking_contract.get_staking_state.return_value = StakingState.STAKED
+    service_manager.registry.prepare_approve_tx.return_value = {"to": "0xApprove"}
 
-        assert service_manager.spin_up(staking_contract=staking_contract) is True
+    assert service_manager.spin_up(staking_contract=staking_contract) is True
 
 
 def test_spin_up_activate_fails(service_manager, mock_wallet):
@@ -587,7 +557,7 @@ def test_spin_up_activate_fails(service_manager, mock_wallet):
 
     # Mock balance/allowance for activate_registration behavior
     mock_wallet.balance_service = MagicMock()
-    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 10**18
+    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 100 * 10**18
     mock_wallet.transfer_service.get_erc20_allowance.return_value = 10**20
 
     mock_wallet.sign_and_send_transaction.return_value = (False, {})
@@ -931,7 +901,7 @@ def test_activate_registration_token_service_sends_security_deposit_as_value(
 
     # Mock balance check to pass
     mock_wallet.balance_service = MagicMock()
-    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 10**18  # Plenty of balance
+    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 100 * 10**18  # Plenty of balance
 
     # Mock allowance to pass check (return an int)
     mock_wallet.transfer_service.get_erc20_allowance.return_value = 10**20  # Plenty of allowance
@@ -964,7 +934,7 @@ def test_activate_registration_native_service_sends_security_deposit_as_value(
 
     # Mock balance/allowance
     mock_wallet.balance_service = MagicMock()
-    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 10**18
+    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 100 * 10**18
     mock_wallet.transfer_service.get_erc20_allowance.return_value = 10**20
 
     service_manager.activate_registration()
@@ -996,7 +966,7 @@ def test_activate_registration_uses_master_account_as_from_address(service_manag
     # Mock balance/allowance
     mock_wallet.balance_service = MagicMock()
     mock_wallet.transfer_service = MagicMock()
-    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 10**18
+    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 100 * 10**18
     mock_wallet.transfer_service.get_erc20_allowance.return_value = 10**20
 
     service_manager.activate_registration()
@@ -1028,7 +998,7 @@ def test_activate_registration_uses_master_account_as_signer(service_manager, mo
     # Mock balance/allowance
     mock_wallet.balance_service = MagicMock()
     mock_wallet.transfer_service = MagicMock()
-    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 10**18
+    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 100 * 10**18
     mock_wallet.transfer_service.get_erc20_allowance.return_value = 10**20
 
     service_manager.activate_registration()
@@ -1055,7 +1025,7 @@ def test_activate_registration_token_service_approves_token_utility(service_mana
 
     # Mock low allowance to trigger approval
     mock_wallet.balance_service = MagicMock()
-    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 10**18
+    mock_wallet.balance_service.get_erc20_balance_wei.return_value = 100 * 10**18
     mock_wallet.transfer_service.get_erc20_allowance.return_value = 0  # Low allowance
     mock_wallet.transfer_service.approve_erc20.return_value = True
 

iwa/plugins/olas/tests/test_service_manager_errors.py

@@ -121,8 +121,7 @@ def test_service_manager_lifecycle_failures(mock_wallet):
         "num_agent_instances": 1,
         "required_agent_bond": 50000000000000000000,
     }
-    with patch("iwa.plugins.olas.service_manager.staking.ERC20Contract"):
-        assert manager.stake(mock_staking) is False
+    assert manager.stake(mock_staking) is False
 
     # unstake failures
     # Service not staked

iwa/plugins/olas/tests/test_service_manager_flows.py

@@ -45,9 +45,8 @@ def mock_config():
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
-@patch("iwa.plugins.olas.service_manager.staking.ERC20Contract")
 def test_create_service_success(
-    mock_erc20, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
+    mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
 ):
     """Test successful service creation."""
     # Setup Config with new OlasConfig structure
@@ -85,9 +84,8 @@ def test_create_service_success(
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
-@patch("iwa.plugins.olas.service_manager.staking.ERC20Contract")
 def test_create_service_failures(
-    mock_erc20, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
+    mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
 ):
     """Test service creation failure modes."""
     mock_config_inst = mock_config_cls.return_value
@@ -141,9 +139,8 @@ def test_create_service_failures(
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
-@patch("iwa.plugins.olas.service_manager.staking.ERC20Contract")
 def test_create_service_with_approval(
-    mock_erc20, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
+    mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
 ):
     """Test service creation with token approval."""
     mock_config_inst = mock_config_cls.return_value
@@ -404,8 +401,7 @@ def test_terminate(mock_sm_contract, mock_registry_contract, mock_config_cls, mo
 @patch(
     "iwa.plugins.olas.service_manager.base.ServiceManagerContract"
 )  # MUST mock specifically here
-@patch("iwa.plugins.olas.service_manager.staking.ERC20Contract")  # For checking balance
-def test_stake(mock_erc20, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
+def test_stake(mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
     """Test service staking."""
     # Setup mock service
     mock_service = MagicMock()
@@ -445,9 +441,6 @@ def test_stake(mock_erc20, mock_sm_contract, mock_registry_contract, mock_config
         "required_agent_bond": 50000000000000000000,
     }
 
-    # Mock ERC20 balance check (100 OLAS = 100e18 wei, enough for 50 min deposit)
-    mock_erc20_inst = mock_erc20.return_value
-    mock_erc20_inst.balance_of_wei.return_value = 100000000000000000000  # 100 OLAS
 
     success = manager.stake(mock_staking)
     assert success is True
@@ -471,10 +464,7 @@ def test_stake(mock_erc20, mock_sm_contract, mock_registry_contract, mock_config
     assert manager.stake(mock_staking) is False
     mock_staking.get_service_ids.return_value = []
 
-    # 3. Not enough funds
-    mock_erc20_inst.balance_of_wei.return_value = 50
-    assert manager.stake(mock_staking) is False
-    mock_erc20_inst.balance_of_wei.return_value = 200
+
 
     # 4. Approve fail
     mock_wallet.sign_and_send_transaction.return_value = (False, {})

iwa/plugins/olas/tests/test_service_manager_validation.py

@@ -45,21 +45,22 @@ def test_drain_service_partial_failures(sm, mock_wallet):
     # 2. Safe drain failure
     # 3. Agent drain success
 
-    with patch.object(sm, "claim_rewards", return_value=(True, 10**18)):
-        # Wallet.drain is called for Safe and Agent
-        def mock_drain(from_address_or_tag=None, to_address_or_tag=None, chain_name=None):
-            if from_address_or_tag == VALID_ADDR_2:  # Safe
-                raise Exception("Safe drain failed")
-            return {"native": 0.5}
-
-        mock_wallet.drain.side_effect = mock_drain
-
-        result = sm.drain_service()
-
-        assert "safe" not in result
-        assert "agent" in result
-        assert result["agent"]["native"] == 0.5
-        # Verify it continued after Safe failure
+    with patch("time.sleep"):  # Avoid real delays in drain operations
+        with patch.object(sm, "claim_rewards", return_value=(True, 10**18)):
+            # Wallet.drain is called for Safe and Agent
+            def mock_drain(from_address_or_tag=None, to_address_or_tag=None, chain_name=None):
+                if from_address_or_tag == VALID_ADDR_2:  # Safe
+                    raise Exception("Safe drain failed")
+                return {"native": 0.5}
+
+            mock_wallet.drain.side_effect = mock_drain
+
+            result = sm.drain_service()
+
+            assert "safe" not in result
+            assert "agent" in result
+            assert result["agent"]["native"] == 0.5
+            # Verify it continued after Safe failure
 
 
 def test_unstake_failed_event_extraction(sm):

iwa/tools/list_contracts.py

@@ -11,8 +11,8 @@ from iwa.core.utils import configure_logger
 from iwa.plugins.olas.constants import OLAS_TRADER_STAKING_CONTRACTS
 from iwa.plugins.olas.contracts.staking import StakingContract
 
-# Configure logger to avoid noise during execution
-logger = configure_logger()
+# Configure logger and silence noisy third-party loggers
+configure_logger()
 logging.getLogger("web3").setLevel(logging.WARNING)
 logging.getLogger("urllib3").setLevel(logging.WARNING)
 

iwa/web/dependencies.py

@@ -1,16 +1,14 @@
 """Shared dependencies for Web API routers."""
 
-import logging
 import secrets
 from typing import Optional
 
 from fastapi import Header, HTTPException, Security
 from fastapi.security import APIKeyHeader
+from loguru import logger
 
 from iwa.core.wallet import Wallet
 
-logger = logging.getLogger(__name__)
-
 # Singleton wallet instance for the web app
 wallet = Wallet()
 

iwa/web/routers/accounts.py

@@ -1,16 +1,15 @@
 """Accounts Router for Web API."""
 
-import logging
 import time
 
 from fastapi import APIRouter, Depends, HTTPException, Request
+from loguru import logger
 from slowapi import Limiter
 from slowapi.util import get_remote_address
 
 from iwa.web.dependencies import verify_auth, wallet
 from iwa.web.models import AccountCreateRequest, SafeCreateRequest
 
-logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/accounts", tags=["accounts"])
 
 # Rate limiter for this router

iwa/web/routers/olas/admin.py

@@ -1,8 +1,7 @@
 """Olas Admin Router."""
 
-import logging
-
 from fastapi import APIRouter, Depends, HTTPException, Request
+from loguru import logger
 from slowapi import Limiter
 from slowapi.util import get_remote_address
 
@@ -10,7 +9,6 @@ from iwa.core.models import Config
 from iwa.plugins.olas.models import OlasConfig
 from iwa.web.dependencies import verify_auth, wallet
 
-logger = logging.getLogger(__name__)
 router = APIRouter(tags=["olas"])
 limiter = Limiter(key_func=get_remote_address)
 

iwa/web/routers/olas/funding.py

@@ -1,8 +1,7 @@
 """Olas Funding Router."""
 
-import logging
-
 from fastapi import APIRouter, Depends, HTTPException, Request
+from loguru import logger
 from pydantic import BaseModel, Field
 from slowapi import Limiter
 from slowapi.util import get_remote_address
@@ -11,7 +10,6 @@ from iwa.core.models import Config
 from iwa.plugins.olas.models import OlasConfig
 from iwa.web.dependencies import verify_auth, wallet
 
-logger = logging.getLogger(__name__)
 router = APIRouter(tags=["olas"])
 limiter = Limiter(key_func=get_remote_address)
 

iwa/web/routers/olas/general.py

@@ -1,12 +1,10 @@
 """Olas General Router."""
 
-import logging
-
 from fastapi import APIRouter, Depends
+from loguru import logger
 
 from iwa.web.dependencies import verify_auth
 
-logger = logging.getLogger(__name__)
 router = APIRouter(tags=["olas"])
 
 

iwa/web/routers/olas/services.py

@@ -1,16 +1,15 @@
 """Olas Services Router."""
 
-import logging
 from typing import Optional
 
 from fastapi import APIRouter, Depends, HTTPException
+from loguru import logger
 from pydantic import BaseModel, Field
 
 from iwa.core.models import Config
 from iwa.plugins.olas.models import OlasConfig
 from iwa.web.dependencies import verify_auth, wallet
 
-logger = logging.getLogger(__name__)
 router = APIRouter(tags=["olas"])
 
 
@@ -29,6 +28,50 @@ class CreateServiceRequest(BaseModel):
     )
 
 
+def _determine_bond_amount(req: CreateServiceRequest) -> int:
+    """Determine the bond amount required for the service."""
+    from web3 import Web3
+
+    from iwa.core.contracts.erc20 import ERC20Contract
+    from iwa.plugins.olas.contracts.staking import StakingContract
+    from iwa.web.dependencies import wallet
+
+    # Default to 1 wei of the service token if no staking contract specified
+    bond_amount = Web3.to_wei(1, "wei")
+
+    if req.token_address and req.staking_contract:
+        # If a contract is specified, we MUST use its requirements
+        logger.info(f"Fetching requirements from {req.staking_contract}...")
+        staking_contract = StakingContract(req.staking_contract, req.chain)
+        reqs = staking_contract.get_requirements()
+        bond_amount = reqs["required_agent_bond"]
+        min_staking_deposit = reqs["min_staking_deposit"]
+        logger.info(f"Required bond amount from contract: {bond_amount} wei")
+        logger.info(f"Required min_staking_deposit: {min_staking_deposit} wei")
+
+        # Validate upfront: total OLAS needed = bond + min_staking_deposit
+        if req.stake_on_create:
+            total_olas_needed = bond_amount + min_staking_deposit
+            logger.info(
+                f"Total OLAS needed for create + stake: {total_olas_needed / 1e18:.2f} OLAS"
+            )
+
+            # Check owner balance (master is default owner for new services)
+            staking_token = reqs.get("staking_token")
+            if staking_token:
+                erc20 = ERC20Contract(staking_token, req.chain)
+                owner_balance = erc20.balance_of_wei(wallet.master_account.address)
+                logger.info(f"Owner OLAS balance: {owner_balance / 1e18:.2f} OLAS")
+
+                if owner_balance < total_olas_needed:
+                    raise HTTPException(
+                        status_code=400,
+                        detail=f"Insufficient OLAS balance. Need {total_olas_needed / 1e18:.2f} OLAS "
+                        f"(bond: {bond_amount / 1e18:.2f} + deposit: {min_staking_deposit / 1e18:.2f}), "
+                        f"but owner has {owner_balance / 1e18:.2f} OLAS",
+                    )
+    return bond_amount
+
 @router.post(
     "/create",
     summary="Create Service",
@@ -37,28 +80,14 @@ class CreateServiceRequest(BaseModel):
 def create_service(req: CreateServiceRequest, auth: bool = Depends(verify_auth)):
     """Create a new Olas service using spin_up for seamless deployment."""
     try:
-        from web3 import Web3
 
         from iwa.plugins.olas.contracts.staking import StakingContract
         from iwa.plugins.olas.service_manager import ServiceManager
 
         manager = ServiceManager(wallet)
 
-        # Determine bond amount based on staking contract
-        bond_amount = 1  # Default for native token (1 wei)
-
-        staking_contract = None
-        if req.token_address:
-            if req.staking_contract:
-                # If a contract is specified, we MUST use its requirements
-                logger.info(f"Fetching requirements from {req.staking_contract}...")
-                staking_contract = StakingContract(req.staking_contract, req.chain)
-                reqs = staking_contract.get_requirements()
-                bond_amount = reqs["required_agent_bond"]
-                logger.info(f"Required bond amount from contract: {bond_amount} wei")
-            else:
-                # Default to 1 wei of the service token if no staking contract specified
-                bond_amount = Web3.to_wei(1, "wei")
+        # Determine bond amount
+        bond_amount = _determine_bond_amount(req)
 
         # Step 1: Create the service (PRE_REGISTRATION state)
         logger.info(
@@ -88,11 +117,14 @@ def create_service(req: CreateServiceRequest, auth: bool = Depends(verify_auth))
 
         # Step 2: Spin up the service (activate → register → deploy → optionally stake)
         # Only pass staking_contract if user wants to stake on create
-        spin_up_staking = staking_contract if req.stake_on_create else None
+        staking_obj = None
+        if req.stake_on_create and req.staking_contract:
+            # We need to instantiate the staking contract object for spin_up
+            staking_obj = StakingContract(req.staking_contract, req.chain)
 
         success = manager.spin_up(
             service_id=service_id,
-            staking_contract=spin_up_staking,
+            staking_contract=staking_obj,
             bond_amount_wei=bond_amount,
         )
 
@@ -111,7 +143,7 @@ def create_service(req: CreateServiceRequest, auth: bool = Depends(verify_auth))
             "service_key": manager.service.key if manager.service else None,
             "multisig": str(manager.service.multisig_address) if manager.service else None,
             "final_state": final_state,
-            "staked": req.stake_on_create and spin_up_staking is not None,
+            "staked": req.stake_on_create and staking_obj is not None,
         }
 
     except HTTPException: