ServiceRegistry (without parameter reconfiguration)

CONTRIBUTING.md

@@ -42,6 +42,12 @@ When you write Solidity code, be aware of the distinction between ``assert(cond)
 
 ``assert(cond)`` and ``require(cond)`` both cause a failure in the EVM execution when ``cond`` evaluates to 0.  They use different EVM opcodes that cause different gas consumptions.  More importantly, a convention dictates when to use which.  Use ``assert(cond)`` only when you are confident that ``cond`` is always true.  When an ``assert`` fires, that's considered as a bug in the Solidity program (or the Solidity compiler).  For detecting invalid user inputs or invalid return values from other contracts, use ``require()``.
 
+#### Returning a Boolean Indicating Success
+
+We currently check the return values from all external function calls.  In the Solidity code, all external function calls should happen within `require(...)` unless the function returns nothing.
+
+When we implement a function that has nothing to return, we make the function always return true.  So we have a more consistent visual look without naked calls.
+
 #### Signature Convention
 
 A signature should be useful only in one context. For this purpose, we follow a convention dictating the format of signed messages. The first fields of a signed message must look like::

raiden_contracts/constants.py

@@ -23,6 +23,7 @@
 CONTRACT_SERVICE_REGISTRY = "ServiceRegistry"
 CONTRACT_USER_DEPOSIT = "UserDeposit"
 CONTRACT_ONE_TO_N = "OneToN"
+CONTRACT_DEPOSIT = "Deposit"
 
 # Timeouts
 TEST_SETTLE_TIMEOUT_MIN = 5
@@ -51,6 +52,9 @@
 # EndpointRegistry
 EVENT_ADDRESS_REGISTERED = "AddressRegistered"
 
+# ServiceRegistry
+EVENT_REGISTERED_SERVICE = "RegisteredService"
+
 
 class ChannelEvent(str, Enum):
     OPENED = "ChannelOpened"

raiden_contracts/data/gas.json

@@ -4,20 +4,22 @@
     "CustomToken.transfer": 36123,
     "CustomToken.transferFrom": 29557,
     "MonitoringService.claimReward": 41931,
-    "MonitoringService.monitor": 207422,
-    "OneToN.claim": 92705,
+    "MonitoringService.monitor": 207736,
+    "OneToN.claim": 92786,
     "SecretRegistry.registerSecret": 46892,
-    "TokenNetwork DEPLOYMENT": 4277369,
-    "TokenNetwork.closeChannel": 111155,
+    "ServiceRegistry.deposit": 433192,
+    "ServiceRegistry.setURL": 44555,
+    "TokenNetwork DEPLOYMENT": 4283201,
+    "TokenNetwork.closeChannel": 111439,
     "TokenNetwork.openChannel": 97745,
-    "TokenNetwork.setTotalDeposit": 44909,
-    "TokenNetwork.setTotalWithdraw": 103306,
-    "TokenNetwork.settleChannel": 108229,
-    "TokenNetwork.unlock 1 locks": 31549,
-    "TokenNetwork.unlock 6 locks": 58649,
-    "TokenNetwork.updateNonClosingBalanceProof": 93786,
-    "TokenNetworkRegistry DEPLOYMENT": 4947971,
-    "TokenNetworkRegistry createERC20TokenNetwork": 3300096,
+    "TokenNetwork.setTotalDeposit": 44845,
+    "TokenNetwork.setTotalWithdraw": 103178,
+    "TokenNetwork.settleChannel": 108197,
+    "TokenNetwork.unlock 1 locks": 31485,
+    "TokenNetwork.unlock 6 locks": 58457,
+    "TokenNetwork.updateNonClosingBalanceProof": 93972,
+    "TokenNetworkRegistry DEPLOYMENT": 4953811,
+    "TokenNetworkRegistry createERC20TokenNetwork": 3304504,
     "UserDeposit.deposit": 92392,
     "UserDeposit.deposit (increase balance)": 32392,
     "UserDeposit.planWithdraw": 64021,

raiden_contracts/data/source/services/ServiceRegistry.sol

@@ -3,49 +3,173 @@ pragma solidity 0.5.4;
 import "raiden/Token.sol";
 import "raiden/Utils.sol";
 
+contract Deposit {
+    // This contract holds ERC20 tokens as deposit until a predetemined point of time.
+
+    // The ERC20 token contract that the deposit is about.
+    Token public token;
+
+    // The address that can withdraw the deposit after the release time.
+    address public withdrawer;
+
+    // The timestamp after which the withdrawer can withdraw the deposit.
+    uint256 public release_at;
+
+    /// @param _token The address of the ERC20 token contract where the deposit is accounted.
+    /// @param _release_at The timestap after which the withdrawer can withdraw the deposit.
+    /// @param _withdrawer The address that can withdraw the deposit after the release time.
+    constructor(address _token, uint256 _release_at, address _withdrawer) public {
+        token = Token(_token);
+        // Don't care even if it's in the past.
+        release_at = _release_at;
+        withdrawer = _withdrawer;
+    }
+
+    // In order to make a deposit, transfer the ERC20 token into this contract.
+    // If you transfer a wrong kind of ERC20 token or ETH into this contract,
+    // these tokens will be lost forever.
+
+    /// @notice Withdraws the tokens that have been deposited.
+    /// Only `withdrawer` can call this.
+    /// @param _to The address where the withdrawn tokens should go.
+    function withdraw(address payable _to) external {
+        uint256 balance = token.balanceOf(address(this));
+        require(msg.sender == withdrawer, "the caller is not the withdrawer");
+        require(now >= release_at, "deposit not released yet");
+        require(balance > 0, "nothing to withdraw");
+        require(token.transfer(_to, balance), "token didn't transfer");
+        selfdestruct(_to); // The contract can disappear.
+    }
+}
+
+
 contract ServiceRegistry is Utils {
     Token public token;
-    address public owner;
 
-    mapping(address => uint256) public deposits;  // token amount staked by the service provider
+    // After a price is set to set_price at timestamp set_price_at,
+    // the price decays according to decayed_price().
+    uint256 public set_price;
+    uint256 public set_price_at;
+
+    // Once the price is at min_price, it can't decay further.
+    uint256 constant min_price = 1000;
+
+    mapping(address => uint256) public service_valid_till;
     mapping(address => string) public urls;  // URLs of services for HTTP access
-    address[] public service_addresses;  // list of available services (ethereum addresses)
+
+    // @param service The address of the registered service provider
+    // @param valid_till The timestamp of the moment when the registration expires
+    // @param deposit_amount The amount of deposit transferred
+    // @param deposit The address of Deposit instance where the deposit is stored.
+    event RegisteredService(address indexed service, uint256 valid_till, uint256 deposit_amount, Deposit deposit_contract);
 
     // @param _token_for_registration The address of the ERC20 token contract that services use for registration fees
-    constructor(address _token_for_registration) public {
+    constructor(address _token_for_registration, uint256 _initial_price) public {
         require(_token_for_registration != address(0x0), "token at address zero");
         require(contractExists(_token_for_registration), "token has no code");
+        require(_initial_price >= min_price, "initial price too low");
 
         token = Token(_token_for_registration);
         // Check if the contract is indeed a token contract
         require(token.totalSupply() > 0, "total supply zero");
-        owner = msg.sender;
+
+        // Set up the price and the set price timestamp
+        set_price = _initial_price;
+        set_price_at = now;
     }
 
-    function deposit(uint amount) public {
-        require(amount > 0);
+    // @notice Locks tokens and registers a service or extends the registration.
+    // @param _limit_amount The biggest amount of tokens that the caller is willing to deposit.
+    // The call fails if the current price is higher (this is always possible
+    // when other parties have just called `deposit()`).
+    function deposit(uint _limit_amount) public returns (bool _success) {
+        uint256 amount = current_price();
+        require(_limit_amount >= amount, "not enough limit");
+
+        // Extend the service position.
+        uint256 valid_till = service_valid_till[msg.sender];
+        if (valid_till < now) { // a first time joiner or an expired service.
+            valid_till = now;
+        }
+        // Check against overflow.
+        require(valid_till < valid_till + 180 days, "overflow during extending the registration");
+        valid_till = valid_till + 180 days;
+        assert(valid_till > service_valid_till[msg.sender]);
+        service_valid_till[msg.sender] = valid_till;
+
+        // Record the price
+        set_price = amount * 6 / 5;
+        set_price_at = now;
+
+        // Move the deposit in a new Deposit contract.
+        Deposit depo = new Deposit(address(token), valid_till, msg.sender);
+        require(token.transferFrom(msg.sender, address(depo), amount), "Token transfer for deposit failed");
 
-        // This also allows for MSs to deposit and use other MSs
-        deposits[msg.sender] += amount;
+        // Fire event
+        emit RegisteredService(msg.sender, valid_till, amount, depo);
 
-        // Transfer the deposit to the smart contract
-        require(token.transferFrom(msg.sender, address(this), amount), "tokens did not transfer");
+        return true;
     }
 
-    /// Set the URL used to access a service via HTTP.
-    /// When this is called for the first time, the service's ethereum address
-    /// is also added to `service_addresses`.
-    function setURL(string memory new_url) public {
+    /// @notice Sets the URL used to access a service via HTTP.
+    /// Only a currently registered service can call this successfully.
+    /// @param new_url The new URL string to be stored.
+    function setURL(string memory new_url) public returns (bool _success)  {
+        require(now < service_valid_till[msg.sender], "registration expired");
         require(bytes(new_url).length != 0, "new url is empty string");
-        if (bytes(urls[msg.sender]).length == 0) {
-            service_addresses.push(msg.sender);
-        }
         urls[msg.sender] = new_url;
+        return true;
+    }
+
+    /// The amount of time till the price decreases to roughly 1/e.
+    uint constant decay_constant = 200 days; // Maybe make this configurable?
+
+    /// @notice Calculates the decreased price after a number of seconds.
+    /// @param _set_price The initial price.
+    /// @param _seconds_passed The number of seconds passed since the initial
+    /// price was set.
+    function decayed_price(uint256 _set_price, uint256 _seconds_passed) public
+        view returns (uint256) {
+        // We are here trying to approximate some exponential decay.
+        // exp(- X / A) where
+        //   X is the number of seconds since the last price change
+        //   A is the decay constant (A = 200 days corresponds to 0.5% decrease per day)
+
+        // exp(- X / A) ~~ P / Q where
+        //   P = 24 A^4
+        //   Q = 24 A^4 + 24 A^3X + 12 A^2X^2 + 4 AX^3 + X^4
+        // Note: swap P and Q, and then think about the Taylor expansion.
+
+        uint256 X = _seconds_passed;
+
+        if (X >= 2 ** 60) { // The computation below overflows.
+            return min_price;
+        }
+
+        uint256 A = decay_constant;
+
+        uint256 P = 24 * (A ** 4);
+        uint256 Q = P + 24*(A**3)*X + 12*(A**2)*(X**2) + 4*A*(X**3) + X**4;
+
+        uint256 price = _set_price * P / Q;
+
+        // Not allowing a price smaller than 1000.
+        // Once it's too low it's too low forever.
+        if (price < min_price) {  // Maybe make this configurable too?
+            price = min_price;
+        }
+        return price;
     }
 
-    /// Returns number of registered services. Useful for accessing service_addresses.
-    function serviceCount() public view returns(uint) {
-        return service_addresses.length;
+    /// @notice The amount of deposits for registration or extension.
+    /// Note: the price moves quickly depending on what other addresses do.
+    /// The current price might change after you send a `deposit()` transaction
+    /// before the transaction is executed.
+    function current_price() public view returns (uint256) {
+        require(now >= set_price_at, "An underflow in price computation");
+        uint256 seconds_passed = now - set_price_at;
+
+        return decayed_price(set_price, seconds_passed);
     }
 }
 

raiden_contracts/deploy/__main__.py

@@ -208,6 +208,12 @@ def raiden(
     type=int,
     help="Maximum amount of tokens deposited in UserDeposit",
 )
+@click.option(
+    "--initial-service-registration-price",
+    required=True,
+    type=int,
+    help="Initial amount of deposit for a registration in ServiceRegistry",
+)
 @click.option("--save-info/--no-save-info", default=True, help="Save deployment info to a file.")
 @click.pass_context
 def services(
@@ -221,12 +227,15 @@ def services(
     save_info: bool,
     contracts_version: Optional[str],
     user_deposit_whole_limit: int,
+    initial_service_registration_price: int,
 ) -> None:
     setup_ctx(ctx, private_key, rpc_provider, wait, gas_price, gas_limit, contracts_version)
     deployer: ContractDeployer = ctx.obj["deployer"]
 
     deployed_contracts_info = deployer.deploy_service_contracts(
-        token_address=token_address, user_deposit_whole_balance_limit=user_deposit_whole_limit
+        token_address=token_address,
+        user_deposit_whole_balance_limit=user_deposit_whole_limit,
+        initial_service_registration_price=initial_service_registration_price,
     )
     deployed_contracts = {
         contract_name: info["address"]

raiden_contracts/deploy/contract_deployer.py

@@ -27,7 +27,10 @@
 from raiden_contracts.utils.file_ops import load_json_from_path
 from raiden_contracts.utils.signature import private_key_to_address
 from raiden_contracts.utils.transaction import check_successful_tx
-from raiden_contracts.utils.versions import contracts_version_expects_deposit_limits
+from raiden_contracts.utils.versions import (
+    contracts_version_expects_deposit_limits,
+    contracts_version_has_initial_service_deposit,
+)
 
 LOG = getLogger(__name__)
 
@@ -303,17 +306,29 @@ def _register_token_network_with_limits(
         return token_network_address
 
     def deploy_service_contracts(
-        self, token_address: HexAddress, user_deposit_whole_balance_limit: int
+        self,
+        token_address: HexAddress,
+        user_deposit_whole_balance_limit: int,
+        initial_service_registration_price: int,
     ) -> DeployedContracts:
         """Deploy 3rd party service contracts"""
+        if not contracts_version_has_initial_service_deposit(
+            self.contract_manager.contracts_version
+        ):
+            raise RuntimeError("Deployment of older service contracts is not suppported.")
+
         chain_id = int(self.web3.version.network)
         deployed_contracts: DeployedContracts = {
             "contracts_version": self.contract_manager.contracts_version,
             "chain_id": chain_id,
             "contracts": {},
         }
 
-        self._deploy_and_remember(CONTRACT_SERVICE_REGISTRY, [token_address], deployed_contracts)
+        self._deploy_and_remember(
+            CONTRACT_SERVICE_REGISTRY,
+            [token_address, initial_service_registration_price],
+            deployed_contracts,
+        )
         user_deposit = self._deploy_and_remember(
             contract_name=CONTRACT_USER_DEPOSIT,
             arguments=[token_address, user_deposit_whole_balance_limit],

raiden_contracts/deploy/contract_verifier.py

@@ -132,9 +132,13 @@ def verify_deployment_data(self, deployment_data: DeployedContracts) -> bool:
             != secret_registry.address
         ):
             raise RuntimeError("secret_registry_address onchain has an unexpected value.")
+        if len(constructor_arguments) != 5:
+            raise RuntimeError(
+                "TokenNetworkRegistry received a wrong number of constructor arguments."
+            )
         if secret_registry.address != constructor_arguments[0]:
             raise RuntimeError(
-                "TokenNetwork's constructor received a different SecretRegistry address."
+                "TokenNetworkRegistry's constructor received a different SecretRegistry address."
             )
         if token_network_registry.functions.chain_id().call() != constructor_arguments[1]:
             raise RuntimeError("TokenNetwork remembers a wrong chain_id.")
@@ -348,14 +352,14 @@ def _verify_service_registry_deployment(
 ) -> None:
     """ Check an onchain deployment of ServiceRegistry and constructor arguments """
     if to_checksum_address(service_registry.functions.token().call()) != token_address:
-        raise RuntimeError("service_registry has a wrong token address")
+        raise RuntimeError("ServiceRegistry has a wrong token address")
+    if len(constructor_arguments) != 2:
+        raise RuntimeError(
+            "ServiceRegistry was deployed with a wrong number of constructor arguments"
+        )
     if token_address != constructor_arguments[0]:
         raise RuntimeError(
             f"expected token addredd {token_address} "
             f"but the constructor argument for {CONTRACT_SERVICE_REGISTRY} is "
             f"{constructor_arguments[0]}"
         )
-    if len(constructor_arguments) != 1:
-        raise RuntimeError(
-            "service_registry was deployed with a wrong number of constructor arguments"
-        )

raiden_contracts/tests/fixtures/__init__.py

@@ -3,6 +3,7 @@
 from .base import *
 from .channel import *
 from .contracts import *
+from .deposit_fixtures import *
 from .monitoring_service import *
 from .one_to_n import *
 from .secret_registry import *

raiden_contracts/tests/fixtures/deposit_fixtures.py

@@ -0,0 +1,16 @@
+from typing import Callable, List
+
+import pytest
+from web3.contract import Contract
+
+from raiden_contracts.constants import CONTRACT_DEPOSIT
+
+
+@pytest.fixture
+def get_deposit_contract(deploy_tester_contract: Callable) -> Callable:
+    """Deploy a Deposit contract with the given arguments"""
+
+    def get(arguments: List) -> Contract:
+        return deploy_tester_contract(CONTRACT_DEPOSIT, arguments)
+
+    return get