@etherisc/gif-next 0.0.2-fd4931b-974 → 0.0.2-fd4ee14-428

package/contracts/shared/InitializableCustom.sol

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+/**
+ * @dev This is copy of OpenZeppelin's Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
+ * Changes:
+ * 1. name is InitializableCustom
+ * 2. no longer abstract
+ * 3. have $._initializeOwner
+ * 4. have constructor where sets _initializeOwner 
+ * 5. initializer() in addition checks for _initializeOwner
+ * 6. reinitializer() is deleted
+ */
+abstract contract InitializableCustom {
+    /**
+     * @dev Storage of the initializable contract.
+     *
+     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
+     * when using with upgradeable contracts.
+     *
+     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
+     */
+    struct InitializableCustomStorage {
+        /**
+         * @dev Indicates that the contract has been initialized.
+         */
+        uint64 _initialized;
+        /**
+         * @dev Indicates that the contract is in the process of being initialized.
+         */
+        bool _initializing;
+        /**
+         * @dev Indicates address that can call function with initializer() modifier.
+         */
+        address _initializeOwner;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.InitializableCustom")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant INITIALIZABLE_CUSTOM_STORAGE = 0x46cd1d813423aaf613c34c7f348d15b2b5e71215e9145b09467e257ea2805a00;
+
+    /**
+     * @dev The contract is already initialized.
+     */
+    error InvalidInitialization();
+
+    /**
+     * @dev The contract initialization function caller is not authorized.
+     */
+    error InvalidInitializationCaller();
+
+    /**
+     * @dev The contract is not initializing.
+     */
+    error NotInitializing();
+
+    /**
+     * @dev Triggered when the contract has been initialized or reinitialized.
+     */
+    event Initialized(uint64 version);
+
+    /**
+     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
+     * `onlyInitializing` functions can be used to initialize parent contracts.
+     *
+     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
+     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
+     * production.
+     *
+     * Emits an {Initialized} event.
+     */
+    modifier initializer() virtual {
+        // solhint-disable-next-line var-name-mixedcase
+        InitializableCustomStorage storage $ = _getInitializableCustomStorage();
+
+        if($._initializeOwner != msg.sender) {
+            revert InvalidInitializationCaller();
+        }
+
+        // Cache values to avoid duplicated sloads
+        bool isTopLevelCall = !$._initializing;
+        uint64 initialized = $._initialized;
+
+        // Allowed calls:
+        // - initialSetup: the contract is not in the initializing state and no previous version was
+        //                 initialized
+        // - construction: the contract is initialized at version 1 (no reininitialization) and the
+        //                 current contract is just being deployed
+        bool initialSetup = initialized == 0 && isTopLevelCall;
+        bool construction = initialized == 1 && address(this).code.length == 0;
+
+        if (!initialSetup && !construction) {
+            revert InvalidInitialization();
+        }
+        $._initialized = 1;
+        if (isTopLevelCall) {
+            $._initializing = true;
+        }
+        _;
+        if (isTopLevelCall) {
+            $._initializing = false;
+            emit Initialized(1);
+        }
+    }
+
+    /**
+     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
+     * {initializer} and {reinitializer} modifiers, directly or indirectly.
+     */
+    modifier onlyInitializing() {
+        _checkInitializing();
+        _;
+    }
+
+    /**
+     * @dev Constructor sets the caller of protected initializer function.
+    */
+    constructor() {
+        // solhint-disable-previous-line var-name-mixedcase
+        InitializableCustomStorage storage $ = _getInitializableCustomStorage();
+        $._initializeOwner = msg.sender;
+    }
+
+    /**
+     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
+     */
+    function _checkInitializing() internal view virtual {
+        if (!_isInitializing()) {
+            revert NotInitializing();
+        }
+    }
+
+    /**
+     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
+     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
+     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
+     * through proxies.
+     *
+     * Emits an {Initialized} event the first time it is successfully executed.
+     */
+    function _disableInitializers() internal virtual {
+        // solhint-disable-next-line var-name-mixedcase
+        InitializableCustomStorage storage $ = _getInitializableCustomStorage();
+
+        if ($._initializing) {
+            revert InvalidInitialization();
+        }
+        if ($._initialized != type(uint64).max) {
+            $._initialized = type(uint64).max;
+            emit Initialized(type(uint64).max);
+        }
+    }
+
+    /**
+     * @dev Returns the highest version that has been initialized. See {reinitializer}.
+     */
+    function _getInitializedVersion() internal view returns (uint64) {
+        return _getInitializableCustomStorage()._initialized;
+    }
+
+    /**
+     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
+     */
+    function _isInitializing() internal view returns (bool) {
+        return _getInitializableCustomStorage()._initializing;
+    }
+
+    /**
+     * @dev Returns a pointer to the storage namespace.
+     */
+    // solhint-disable-next-line var-name-mixedcase
+    function _getInitializableCustomStorage() private pure returns (InitializableCustomStorage storage $) {
+        assembly {
+            $.slot := INITIALIZABLE_CUSTOM_STORAGE
+        }
+    }
+}

package/contracts/shared/InstanceLinkedComponent.sol

@@ -12,13 +12,12 @@ import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IInstance} from "../instance/IInstance.sol";
-import {InstanceAccessManager} from "../instance/InstanceAccessManager.sol";
+import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {NftId} from "../type/NftId.sol";
 import {ObjectType, COMPONENT, INSTANCE} from "../type/ObjectType.sol";
 import {VersionPart} from "../type/Version.sol";
-import {Registerable} from "../shared/Registerable.sol";
 import {RoleId, RoleIdLib} from "../type/RoleId.sol";
 import {IAccess} from "../instance/module/IAccess.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";

package/contracts/shared/KeyValueStore.sol

@@ -34,14 +34,12 @@ contract KeyValueStore is
             revert ErrorKeyValueStoreAlreadyCreated(key32, objectType);
         }
 
-        address createdBy = msg.sender;
         Blocknumber blocknumber = blockBlocknumber();
         StateId initialState = hasLifecycle(objectType) ? getInitialState(objectType) : ACTIVE();
 
         // set metadata
         metadata.objectType = objectType;
         metadata.state = initialState;
-        metadata.updatedBy = createdBy;
         metadata.updatedIn = blocknumber;
         metadata.createdIn = blocknumber;
 
@@ -49,7 +47,7 @@ contract KeyValueStore is
         _value[key32].data = data;
 
         // solhint-disable-next-line avoid-tx-origin
-        emit LogInfoCreated(key32.toObjectType(), key32.toKeyId(), initialState, createdBy, tx.origin);
+        emit LogInfoCreated(key32.toObjectType(), key32.toKeyId(), initialState, msg.sender, tx.origin);
     }
 
 
@@ -100,7 +98,6 @@ contract KeyValueStore is
         }
 
         // update metadata
-        metadata.updatedBy = msg.sender;
         metadata.updatedIn = blockBlocknumber();
     }
 

package/contracts/shared/Lifecycle.sol

@@ -4,8 +4,8 @@ pragma solidity ^0.8.20;
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK, CLAIM, PAYOUT} from "../type/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID} from "../type/StateId.sol";
+import {ObjectType, COMPONENT, BUNDLE, POLICY, REQUEST, RISK, CLAIM, PAYOUT} from "../type/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID, FULFILLED, FAILED, CANCELLED} from "../type/StateId.sol";
 import {ILifecycle} from "./ILifecycle.sol";
 
 contract Lifecycle is
@@ -27,6 +27,7 @@ contract Lifecycle is
         _setupPolicyLifecycle();
         _setupClaimAndPayoutLifecycle();
         _setupRiskLifecycle();
+        _setupRequestLifecycle();
     }
 
     function hasLifecycle(
@@ -118,4 +119,12 @@ contract Lifecycle is
         _isValidTransition[RISK()][PAUSED()][ACTIVE()] = true;
         _isValidTransition[RISK()][PAUSED()][ARCHIVED()] = true;
     }
+
+    function _setupRequestLifecycle() internal {
+        _initialState[REQUEST()] = ACTIVE();
+        _isValidTransition[REQUEST()][ACTIVE()][FULFILLED()] = true;
+        _isValidTransition[REQUEST()][ACTIVE()][FAILED()] = true;
+        _isValidTransition[REQUEST()][FAILED()][FULFILLED()] = true;
+        _isValidTransition[REQUEST()][ACTIVE()][CANCELLED()] = true;
+    }
 }

package/contracts/shared/NftIdSetManager.sol

@@ -22,12 +22,8 @@ contract NftIdSetManager {
         _;
     }
 
-    function setOwner(address owner) external {
-        if(_owner != address(0)) {
-            revert ErrorNftIdSetManagerOwnerAlreadySet(_owner);
-        }
-
-        _owner = owner;
+    constructor() {
+        _owner = msg.sender;
     }
 
     function add(NftId objectNftId) external onlyOwner {

package/contracts/shared/NftOwnable.sol

@@ -56,20 +56,9 @@ contract NftOwnable is
     function linkToRegisteredNftId()
         public
         virtual
+        returns (NftId nftId)
     {
-        NftOwnableStorage storage $ = _getNftOwnableStorage();
-
-        if ($._nftId.gtz()) {
-            revert ErrorNftOwnableAlreadyLinked($._nftId);
-        }
-
-        address contractAddress = address(this);
-
-        if (!getRegistry().isRegistered(contractAddress)) {
-            revert ErrorNftOwnableContractNotRegistered(contractAddress);
-        }
-
-        $._nftId = getRegistry().getNftId(contractAddress);
+        return _linkToNftOwnable(address(this));
     }
 
     function getNftId() public view virtual override returns (NftId) {

package/contracts/shared/PolicyHolder.sol

@@ -12,11 +12,12 @@ import {IPolicyHolder} from "./IPolicyHolder.sol";
 import {NftId} from "../type/NftId.sol";
 import {PayoutId, PayoutIdLib} from "../type/PayoutId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
 
 /// @dev template implementation for IPolicyHolder
 contract PolicyHolder is
     ERC165,
-    RegistryLinked,
+    RegistryLinked, // TODO need upgradeable version
     IPolicyHolder
 {
     // keccak256(abi.encode(uint256(keccak256("etherisc.storage.PolicyHolder")) - 1)) & ~bytes32(uint256(0xff));

package/contracts/shared/ProxyManager.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.20;
 
 import {ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
-import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 
 import {Blocknumber, blockNumber} from "../type/Blocknumber.sol";
 import {IVersionable} from "./IVersionable.sol";
@@ -12,6 +11,7 @@ import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.s
 import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
 import {UpgradableProxyWithAdmin} from "./UpgradableProxyWithAdmin.sol";
 import {Version, VersionLib} from "../type/Version.sol";
+import {NftId} from "../type/NftId.sol";
 
 /// @dev manages proxy deployments for upgradable contracs of type IVersionable
 contract ProxyManager is
@@ -132,6 +132,10 @@ contract ProxyManager is
 
     }
 
+    function linkToProxy() public returns (NftId) {
+        return _linkToNftOwnable(address(_proxy));
+    }
+
     function getDeployData(address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
         return abi.encodeWithSelector(
             IVersionable.initializeVersionable.selector, 
@@ -145,7 +149,7 @@ contract ProxyManager is
             upgradeData);
     }
 
-    function getProxy() public returns (UpgradableProxyWithAdmin) {
+    function getProxy() public view returns (UpgradableProxyWithAdmin) {
         return _proxy;
     }
 

package/contracts/shared/Service.sol

@@ -1,20 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
-import {ObjectType, REGISTRY, SERVICE} from "../type/ObjectType.sol";
-import {NftId} from "../type/NftId.sol";
-import {Version, VersionPart, VersionLib, VersionPartLib} from "../type/Version.sol";
-
-import {Versionable} from "./Versionable.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
 import {IService} from "./IService.sol";
 import {IVersionable} from "./IVersionable.sol";
-import {Versionable} from "./Versionable.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, REGISTRY, SERVICE} from "../type/ObjectType.sol";
 import {Registerable} from "./Registerable.sol";
-
-import {IRegistry} from "../registry/IRegistry.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
+import {Version, VersionPart, VersionLib, VersionPartLib} from "../type/Version.sol";
+import {Versionable} from "./Versionable.sol";
 
 
 /// @dev service base contract
@@ -27,15 +25,6 @@ abstract contract Service is
 
     uint8 private constant GIF_MAJOR_VERSION = 3;
 
-    // from Versionable
-    function getVersion()
-        public 
-        pure 
-        virtual override (IVersionable, Versionable)
-        returns(Version)
-    {
-        return VersionLib.toVersion(GIF_MAJOR_VERSION,0,0);
-    }
 
     function initializeService(
         address registry, 
@@ -58,9 +47,7 @@ abstract contract Service is
         if(authority != address(0)) {
             __AccessManaged_init(authority);
         } else {
-            address registryServiceAddress = getRegistry().getServiceAddress(
-                REGISTRY(), 
-                VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
+            address registryServiceAddress = _getServiceAddress(REGISTRY());
 
             // copy authority from already registered registry services
             __AccessManaged_init(IAccessManaged(registryServiceAddress).authority());
@@ -70,8 +57,27 @@ abstract contract Service is
         registerInterface(type(IService).interfaceId);
     }
 
+    function getDomain() external virtual pure returns(ObjectType serviceDomain) {
+        return _getDomain();
+    }
+
+    function getRoleId() external virtual pure returns(RoleId serviceRoleId) {
+        return RoleIdLib.roleForTypeAndVersion(_getDomain(), VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
+    }
+
+    // from Versionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(GIF_MAJOR_VERSION,0,0);
+    }
+
+    function _getDomain() internal virtual pure returns (ObjectType);
 
     function _getServiceAddress(ObjectType domain) internal view returns (address) {
-        return getRegistry().getServiceAddress(domain, getVersion().toMajorPart());
+        return getRegistry().getServiceAddress(domain, VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
     }
 }

package/contracts/staking/IStaking.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
-import {IKeyValueStore} from "../shared/IKeyValueStore.sol";
 import {IComponent} from "../shared/IComponent.sol";
 import {IVersionable} from "../shared/IVersionable.sol";
 import {NftId} from "../type/NftId.sol";
@@ -10,20 +9,36 @@ import {NftIdSetManager} from "../shared/NftIdSetManager.sol";
 import {ObjectType} from "../type/ObjectType.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {StakingReader} from "./StakingReader.sol";
+import {StakingStore} from "./StakingStore.sol";
 import {Timestamp} from "../type/Timestamp.sol";
 import {UFixed} from "../type/UFixed.sol";
 
 interface IStaking is 
-    IKeyValueStore, 
     IComponent,
     IVersionable
 {
+    // staking rate
+    event LogStakingStakingRateSet(uint256 chainId, address token, UFixed oldStakingRate, UFixed newStakingRate);
 
-    event LogStakingTargetAdded(NftId targetNftId, ObjectType objectType, uint256 chainId);
-    event LogStakingLockingPeriodSet(NftId targetNftId, Seconds lockingDuration);
+    // target parameters
+    event LogStakingLockingPeriodSet(NftId targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod);
+    event LogStakingRewardRateSet(NftId targetNftId, UFixed oldRewardRate, UFixed rewardRate);
 
-    error ErrorStakingStakingReaderStakingMismatch(address stakingByStakingReader);
+    // modifiers
+    error ErrorStakingNotStake(NftId stakeNftId);
+    error ErrorStakingNotTarget(NftId targetNftId);
+
+    error ErrorStakingNotStakingOwner();
     error ErrorStakingNotNftOwner(NftId nftId);
+
+    // staking rate
+    error ErrorStakingTokenNotRegistered(uint256 chainId, address token);
+
+    // check dip balance and allowance
+    error ErrorStakingDipBalanceInsufficient(address owner, uint256 amount, uint256 dipBalance);
+    error ErrorStakingDipAllowanceInsufficient(address owner, address tokenHandler, uint256 amount, uint256 dipAllowance);
+
+    error ErrorStakingStakingReaderStakingMismatch(address stakingByStakingReader);
     error ErrorStakingTargetAlreadyRegistered(NftId targetNftId);
     error ErrorStakingTargetNftIdZero();
     error ErrorStakingTargetTypeNotSupported(NftId targetNftId, ObjectType objectType);
@@ -34,12 +49,12 @@ interface IStaking is
     error ErrorStakingTargetNotFound(NftId targetNftId);
     error ErrorStakingTargetTokenNotFound(NftId targetNftId, uint256 chainId, address token);
 
+    error ErrorStakingTargetNotActive(NftId targetNftId);
+    error ErrorStakingStakeAmountZero(NftId targetNftId);
+
     // info for individual stake
     struct StakeInfo {
-        Amount stakeAmount;
-        Amount rewardAmount;
         Timestamp lockedUntil;
-        Timestamp rewardsUpdatedAt;
     }
 
     struct TargetInfo {
@@ -47,16 +62,14 @@ interface IStaking is
         uint256 chainId;
         Seconds lockingPeriod;
         UFixed rewardRate;
-        Amount rewardReserveAmount;
     }
 
-    // rate management 
+    // staking rate management 
+
+    /// @dev sets the rate that converts 1 token of total value locked into the
+    /// the required staked dip amount to back up the locked token value
     function setStakingRate(uint256 chainId, address token, UFixed stakingRate) external;
 
-    // reward management 
-    function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
-    function refillRewardReserves(NftId targetNftId, Amount dipAmount) external;
-    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount) external;
 
     // target management
 
@@ -70,44 +83,86 @@ interface IStaking is
 
 
     /// @dev set the stake locking period to the specified duration.
-    /// permissioned: only the owner of the specified target may set the locking period
+    /// permissioned: only the staking service may call this function
     function setLockingPeriod(NftId targetNftId, Seconds lockingPeriod) external;
 
-    function increaseTvl(NftId targetNftId, address token, Amount amount) external;
-    function decreaseTvl(NftId targetNftId, address token, Amount amount) external;
+    /// @dev update the target specific reward rate.
+    /// permissioned: only the staking service may call this function
+    function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
+
+    /// @dev (re)fills the staking reward reserves for the specified target
+    /// unpermissioned: anybody may fill up staking reward reserves
+    function refillRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+
+    /// @dev defunds the staking reward reserves for the specified target
+    /// permissioned: only the staking service may call this function
+    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+
+
+    /// @dev increases the total value locked amount for the specified target by the provided token amount.
+    /// function is called when a new policy is collateralized.
+    /// function restricted to the pool service.
+    function increaseTotalValueLocked(NftId targetNftId, address token, Amount amount) external returns (Amount newBalance);
+
+
+    /// @dev decreases the total value locked amount for the specified target by the provided token amount.
+    /// function is called when a new policy is closed or payouts are executed.
+    /// function restricted to the pool service.
+    function decreaseTotalValueLocked(NftId targetNftId, address token, Amount amount) external returns (Amount newBalance);
+
 
     function updateRemoteTvl(NftId targetNftId, address token, Amount amount) external;
 
     // staking functions
 
-    /// @dev creates/stores a new stake info object
+    /// @dev creat a new stake info object
     /// permissioned: only staking service may call this function.
-    function create(NftId stakeNftId, NftId targetNftId, Amount dipAmount) external;
-
-    function stake(NftId stakeNftId, Amount dipAmount) external;
-    function restakeRewards(NftId stakeNftId) external;
-    function restakeToNewTarget(NftId stakeNftId, NftId newTarget) external;
-    function unstake(NftId stakeNftId) external;
-    function unstake(NftId stakeNftId, Amount dipAmount) external;  
-    function claimRewards(NftId stakeNftId) external;
+    function createStake(NftId stakeNftId, NftId targetNftId, Amount dipAmount) external;
 
-    // view and pure functions (staking reader?)
+    /// @dev increase the staked dip by dipAmount for the specified stake.
+    /// staking rewards are updated and added to the staked dips as well.
+    /// the function returns the new total amount of staked dips.
+    function stake(NftId stakeNftId, Amount dipAmount) external returns (Amount stakeBalance);
 
-    function getStakingReader() external view returns (StakingReader reader);
+    /// @dev restakes the dips to a new target.
+    /// the sum of the staked dips and the accumulated rewards will be restaked.
+    /// permissioned: only staking service may call this function.
+    function restake(NftId stakeNftId, NftId newTargetNftId) external returns (NftId newStakeNftId);
 
-    // function getStakeInfo(NftId stakeNftId) external view returns (StakeInfo memory stakeInfo);
-    // function getTargetInfo(NftId targetNftId) external view returns (TargetInfo memory targetInfo);
+    /// @dev retuns the specified amount of dips to the holder of the specified stake nft.
+    /// if dipAmount is set to Amount.max() all staked dips and all rewards are transferred to 
+    /// permissioned: only staking service may call this function.
+    function unstake(NftId stakeNftId)
+        external
+        returns (
+            Amount unstakedAmount,
+            Amount rewardsClaimedAmount
+        );
+
+    /// @dev update stake rewards for current time.
+    /// may be called before an announement of a decrease of a reward rate reduction.
+    /// calling this functions ensures that reward balance is updated using the current (higher) reward rate.
+    /// unpermissioned.
+    function updateRewards(NftId stakeNftId) external;
+
+    /// @dev transfers all rewards accumulated so far to the holder of the specified stake nft.
+    /// permissioned: only staking service may call this function.
+    function claimRewards(NftId stakeNftId)
+        external
+        returns (
+            Amount rewardsClaimedAmount
+        );
 
-    function getTargetManager() external view returns (NftIdSetManager targetManager);
+    //--- helper functions --------------------------------------------------//
 
-    function getTvlAmount(NftId targetNftId, address token) external view returns (Amount tvlAmount);
-    function getStakedAmount(NftId targetNftId) external view returns (Amount stakeAmount);
+    /// @dev transfers the specified amount of dips from the from address to the staking wallet.
+    function collectDipAmount(address from, Amount dipAmount) external;
 
-    function getStakingRate(uint256 chainId, address token) external view returns (UFixed stakingRate);
+    /// @dev transfers the specified amount of dips from the staking wallet to the to addess.
+    function transferDipAmount(address to, Amount dipAmount) external;
 
-    function calculateRewardIncrementAmount(
-        NftId targetNftId,
-        Timestamp rewardsLastUpdatedAt
-    ) external view returns (Amount rewardIncrementAmount);
+    //--- view and pure functions -------------------------------------------//
 
+    function getStakingStore() external view returns (StakingStore stakingStore);
+    function getStakingReader() external view returns (StakingReader reader);
 }