@etherisc/gif-next 0.0.2-7f39e38-904 → 0.0.2-7fbee0d-269

package/contracts/staking/Staking.sol

@@ -1,30 +1,35 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Amount, AmountLib} from "../type/Amount.sol";
-import {ChainNft} from "../registry/ChainNft.sol";
-import {Component} from "../shared/Component.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
 import {IRegistry} from "../registry/IRegistry.sol";
-import {IRegistryService} from "../registry/IRegistryService.sol";
+import {IRelease} from "../registry/IRelease.sol";
 import {IStaking} from "./IStaking.sol";
-import {IVersionable} from "../shared/IVersionable.sol";
-import {Key32} from "../type/Key32.sol";
-import {KEEP_STATE} from "../type/StateId.sol";
-import {LibNftIdSet} from "../type/NftIdSet.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
-import {NftIdSetManager} from "../shared/NftIdSetManager.sol";
-import {ObjectType, INSTANCE, PROTOCOL, STAKE, STAKING, TARGET} from "../type/ObjectType.sol";
+import {IStakingService} from "./IStakingService.sol";
+import {ITargetLimitHandler} from "./ITargetLimitHandler.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Blocknumber} from "../type/Blocknumber.sol";
+import {ChainId, ChainIdLib} from "../type/ChainId.sol";
+import {Component} from "../shared/Component.sol";
+import {IComponent} from "../shared/IComponent.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, PROTOCOL, INSTANCE, STAKE, STAKING, TARGET} from "../type/ObjectType.sol";
 import {Seconds, SecondsLib} from "../type/Seconds.sol";
-import {StakeManagerLib} from "./StakeManagerLib.sol";
+import {Registerable} from "../shared/Registerable.sol";
+import {StakingLib} from "./StakingLib.sol";
 import {StakingReader} from "./StakingReader.sol";
 import {StakingStore} from "./StakingStore.sol";
-import {TargetManagerLib} from "./TargetManagerLib.sol";
-import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+import {TargetHandler} from "./TargetHandler.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
+import {TokenHandlerDeployerLib} from "../shared/TokenHandlerDeployerLib.sol";
 import {TokenRegistry} from "../registry/TokenRegistry.sol";
 import {UFixed, UFixedLib} from "../type/UFixed.sol";
-import {Version, VersionLib} from "../type/Version.sol";
-import {Versionable} from "../shared/Versionable.sol";
+import {Version, VersionLib, VersionPart, VersionPartLib} from "../type/Version.sol";
+import {Versionable} from "../upgradeability/Versionable.sol";
+
 
 contract Staking is 
     Component,
@@ -32,464 +37,755 @@ contract Staking is
     IStaking
 {
     string public constant CONTRACT_NAME = "Staking";
-    uint8 private constant GIF_MAJOR_VERSION = 3;
 
     // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.component.Staking.sol")) - 1)) & ~bytes32(uint256(0xff));
     bytes32 public constant STAKING_LOCATION_V1 = 0xafe8d4462b2ed26a47154f4b8f6d1497d2f772496965791d25bd456e342b7f00;
 
     struct StakingStorage {
-        IRegistryService _registryService;
         TokenRegistry _tokenRegistry;
+        TokenHandler _tokenHandler;
+        IStakingService _stakingService;
+        TargetHandler _targetHandler;
         StakingStore _store;
         StakingReader _reader;
+        NftId _protocolNftId;
+    }
 
-        mapping(uint256 chainId => mapping(address token => UFixed stakingRate)) _stakingRate;
 
-        mapping(NftId targetNftId => Amount stakedAmount) _stakedAmount;
-        mapping(NftId targetNftId => mapping(address token => Amount tvlAmount)) _tvlAmount;
+    modifier onlyStakeOwner(NftId stakeNftId) {
+        _checkTypeAndOwner(stakeNftId, STAKE(), true);
+        _;
+    }
 
-        NftId _protocolNftId;
+
+    modifier onlyTarget(NftId targetNftId) {
+        _checkTypeAndOwner(targetNftId, TARGET(), false);
+        _;
     }
 
 
-    modifier onlyStake(NftId stakeNftId) {
-        if (!_getStakingStorage()._store.exists(stakeNftId)) {
-            revert ErrorStakingNotStake(stakeNftId);
-        }
+    modifier onlyTargetOwner(NftId targetNftId) {
+        _checkTypeAndOwner(targetNftId, TARGET(), true);
         _;
     }
 
+    //--- contract intitialization -------------------------------------------
 
-    modifier onlyTarget(NftId targetNftId) {
-        if (!_getStakingStorage()._store.getTargetManager().exists(targetNftId)) {
-            revert ErrorStakingNotTarget(targetNftId);
+    function initializeTokenHandler()
+        external
+        virtual
+    {
+        if (msg.sender != address(getRegistry())) {
+            revert ErrorStakingNotRegistry(msg.sender);
         }
-        _;
+
+        StakingStorage storage $ = _getStakingStorage();
+        address dipToken = _getStakingStorage()._tokenRegistry.getDipTokenAddress();
+        $._tokenHandler = TokenHandlerDeployerLib.deployTokenHandler(
+            address(getRegistry()),
+            address(this),
+            dipToken, 
+            getRegistry().getAuthority());
     }
 
 
-    // from Versionable
-    function getVersion()
-        public 
-        pure 
-        virtual override (IVersionable, Versionable)
-        returns(Version)
+    //--- staking owner functions -------------------------------------------//
+
+    function setSupportInfo(
+        ObjectType targetType,
+        bool isSupported,
+        bool allowNewTargets,
+        bool allowCrossChain,
+        Amount minStakingAmount,
+        Amount maxStakingAmount,
+        Seconds minLockingPeriod,
+        Seconds maxLockingPeriod,
+        UFixed minRewardRate,
+        UFixed maxRewardRate
+    )
+        external
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.setSupportInfo(
+            targetType,
+            isSupported,
+            allowNewTargets,
+            allowCrossChain,
+            minStakingAmount,
+            maxStakingAmount,
+            minLockingPeriod,
+            maxLockingPeriod,
+            minRewardRate,
+            maxRewardRate);
+    }
+
+
+    /// @inheritdoc IStaking
+    function setUpdateTriggers(
+        uint16 tvlUpdatesTrigger,
+        UFixed minTvlRatioTrigger
+    )
+        external
+        restricted()
+    {
+        StakingStorage storage $ = _getStakingStorage();
+        $._targetHandler.setUpdateTriggers(tvlUpdatesTrigger, minTvlRatioTrigger);
+    }
+
+
+    /// @inheritdoc IStaking
+    function setProtocolLockingPeriod(Seconds newLockingPeriod)
+        external
+        virtual
+        restricted()
+        onlyOwner()
     {
-        return VersionLib.toVersion(GIF_MAJOR_VERSION,0,0);
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.setLockingPeriod($._protocolNftId, newLockingPeriod);
     }
 
-    // set/update staking reader
-    function setStakingReader(StakingReader stakingReader)
+
+    /// @inheritdoc IStaking
+    function setProtocolRewardRate(UFixed newRewardRate)
         external
         virtual
-        onlyOwner
+        restricted()
+        onlyOwner()
     {
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.setRewardRate($._protocolNftId, newRewardRate);
+    }
+
+
+    /// @inheritdoc IStaking
+    function setStakingRate(
+        ChainId chainId, 
+        address token, 
+        UFixed stakingRate
+    )
+        external
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        (
+            UFixed oldStakingRate,
+            Blocknumber lastUpdateIn
+        )  = _getStakingStorage()._store.setStakingRate(chainId, token, stakingRate);
+
+        emit LogStakingStakingRateSet(chainId, token, stakingRate, oldStakingRate, lastUpdateIn);
+    }
+
+
+    /// @inheritdoc IStaking
+    function setStakingService(VersionPart release)
+        external
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        // effects
+        StakingStorage storage $ = _getStakingStorage();
+        address oldStakingService = address($._stakingService);
+        $._stakingService = StakingLib.checkAndGetStakingService(getRegistry(), release);
+
+        emit LogStakingStakingServiceSet(address($._stakingService), release, oldStakingService);
+    }
+
+
+    /// @inheritdoc IStaking
+    function setStakingReader(address reader)
+        external
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        StakingReader stakingReader = StakingReader(reader);
+
         if(stakingReader.getStaking() != IStaking(this)) {
             revert ErrorStakingStakingReaderStakingMismatch(address(stakingReader.getStaking()));
         }
 
-        _getStakingStorage()._reader = stakingReader;
+        StakingStorage storage $ = _getStakingStorage();
+        $._reader = stakingReader;
+        $._store.setStakingReader(reader);
     }
 
 
-    // rate management 
-    function setStakingRate(uint256 chainId, address token, UFixed stakingRate)
+    // TODO move to TargetHandler?
+    /// @inheritdoc IStaking
+    function addToken(
+        ChainId chainId, 
+        address token
+    )
         external
         virtual
-        onlyOwner
+        restricted()
+        onlyOwner()
+    {
+        _addToken(
+            _getStakingStorage(), chainId, token);
+    }
+
+
+    /// @inheritdoc IStaking
+    function approveTokenHandler(IERC20Metadata token, Amount amount)
+        public
+        virtual
+        restricted()
+        onlyOwner()
     {
+        StakingStorage storage $ = _getStakingStorage();
+        Amount oldAllowanceAmount = AmountLib.toAmount(
+            token.allowance(
+                address(this), 
+                address($._tokenHandler)));
 
+        // staking token handler approval via its own implementation in staking service
+        $._stakingService.approveTokenHandler(
+            token, 
+            amount);
+
+        emit LogStakingTokenHandlerApproved(address(token), amount, oldAllowanceAmount);
     }
 
-    // reward management 
+    //--- target management -------------------------------------------------//
+
+
+    /// @inheritdoc IStaking
+    function refillRewardReserves(NftId targetNftId, Amount dipAmount)
+        external
+        virtual
+        restricted()
+        onlyTarget(targetNftId)
+        returns (Amount newBalance)
+    {
+        address transferFrom = msg.sender;
+        _refillRewardReserves(targetNftId, dipAmount, transferFrom);
+    }
 
-    // target management
 
+    /// @inheritdoc IStaking
+    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount)
+        external
+        virtual
+        restricted()
+        onlyTarget(targetNftId)
+        returns (Amount newBalance)
+    {
+        address transferTo;
+    
+        // case 1: protocol target: staking owner is recipient
+        if (targetNftId == getRegistry().getProtocolNftId()) {
+            // verify that the caller is the staking owner
+            transferTo = getOwner();
+            if (msg.sender != transferTo) {
+                revert ErrorStakingNotStakingOwner();
+            }
+
+        // case 2: same chain target: target owner is recipient
+        } else if (ChainIdLib.isCurrentChain(targetNftId)) {
+            // verify that the caller is the target owner
+            transferTo = getRegistry().ownerOf(targetNftId);
+            if (msg.sender != transferTo) {
+                revert ErrorStakingNotNftOwner(targetNftId);
+            }
+
+        // case 3: cross-chain target: TODO decide how to handle and implement
+        } else {
+            revert("Cross-chain target not supported");
+        }
+
+        newBalance = _withdrawRewardReserves(targetNftId, dipAmount, transferTo);
+    }
+
+
+    /// @inheritdoc IStaking
+    function refillRewardReservesByService(NftId targetNftId, Amount dipAmount, address transferFrom)
+        external
+        virtual
+        restricted()
+        onlyTarget(targetNftId)
+        returns (Amount newBalance)
+    {
+        _refillRewardReserves(targetNftId, dipAmount, transferFrom);
+    }
+
+
+    /// @inheritdoc IStaking
+    function withdrawRewardReservesByService(NftId targetNftId, Amount dipAmount, address transferTo)
+        external
+        virtual
+        restricted()
+        onlyTarget(targetNftId)
+        returns (Amount newBalance)
+    {
+        // check that service does not withdraw from protocol target 
+        if (targetNftId == getRegistry().getProtocolNftId()) {
+            revert ErrorStakingTargetTypeNotSupported(targetNftId, PROTOCOL());
+        }
+
+        // default: on-chain target owner is recipient
+        address targetOwner = getRegistry().ownerOf(targetNftId);
+        return _withdrawRewardReserves(targetNftId, dipAmount, targetOwner);
+    }
+
+
+    /// @inheritdoc IStaking
     function registerTarget(
         NftId targetNftId,
         ObjectType expectedObjectType,
-        uint256 chainId,
         Seconds initialLockingPeriod,
         UFixed initialRewardRate
     )
         external
         virtual
-        // restricted // staking service access
+        restricted() // staking service
     {
-        TargetManagerLib.checkTargetParameters(
-            getRegistry(), 
-            _getStakingStorage()._reader,
-            targetNftId, 
-            expectedObjectType, 
-            initialLockingPeriod, 
-            initialRewardRate);
-
+        // checks done by staking store
         _getStakingStorage()._store.createTarget(
             targetNftId,
-            TargetInfo({
-                objectType: expectedObjectType,
-                chainId: chainId,
-                lockingPeriod: initialLockingPeriod,
-                rewardRate: initialRewardRate}));
+            expectedObjectType,
+            initialLockingPeriod,
+            initialRewardRate);
     }
 
 
+    /// @inheritdoc IStaking
     function setLockingPeriod(
         NftId targetNftId, 
         Seconds lockingPeriod
     )
         external
         virtual
-        // TODO add restricted // only staking service
-        onlyTarget(targetNftId) // maybe duplicate check
+        restricted()
+        onlyTarget(targetNftId)
     {
-        (
-            Seconds oldLockingPeriod,
-            TargetInfo memory targetInfo
-        ) = TargetManagerLib.updateLockingPeriod(
-            this,
-            targetNftId,
-            lockingPeriod);
-        
-        _getStakingStorage()._store.updateTarget(targetNftId, targetInfo);
-
-        emit LogStakingLockingPeriodSet(targetNftId, oldLockingPeriod, lockingPeriod);
+        _getStakingStorage()._store.setLockingPeriod(targetNftId, lockingPeriod);
     }
 
-    // TODO add function to set protocol reward rate: onlyOwner
-    // get protocol nft id (from where)
 
+    /// @inheritdoc IStaking
     function setRewardRate(NftId targetNftId, UFixed rewardRate)
         external
         virtual
-        onlyTarget(targetNftId) // maybe duplicate check
+        restricted()
+        onlyTarget(targetNftId)
     {
-        (
-            UFixed oldRewardRate,
-            TargetInfo memory targetInfo
-        ) = TargetManagerLib.updateRewardRate(
-            this,
-            targetNftId,
-            rewardRate);
-        
-        _getStakingStorage()._store.updateTarget(targetNftId, targetInfo);
-
-        emit LogStakingRewardRateSet(targetNftId, oldRewardRate, rewardRate);
+        _getStakingStorage()._store.setRewardRate(targetNftId, rewardRate);
     }
 
 
-    function refillRewardReserves(NftId targetNftId, Amount dipAmount)
+    // TODO refactor into setTargetLimits
+    /// @inheritdoc IStaking
+    function setMaxStakedAmount(NftId targetNftId, Amount stakeLimitAmount)
         external
         virtual
+        restricted()
+        onlyTarget(targetNftId)
     {
-
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.setMaxStakedAmount(targetNftId, stakeLimitAmount);
     }
 
-    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount)
+
+    /// @inheritdoc IStaking
+    function setTargetLimits(NftId targetNftId, Amount marginAmount, Amount limitAmount)
         external
         virtual
-        // onlyNftOwner(targetNftId)
+        restricted()
+        onlyTargetOwner(targetNftId)
     {
-        
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.setTargetLimits(targetNftId, marginAmount, limitAmount);
     }
 
 
-    function increaseTvl(NftId targetNftId, address token, Amount amount)
+    /// @inheritdoc IStaking
+    function addTargetToken(NftId targetNftId, address token)
         external
         virtual
-        // restricted // service to service access
+        restricted()
+        onlyTarget(targetNftId)
     {
+        StakingStorage storage $ = _getStakingStorage();
+        ChainId chainId = ChainIdLib.fromNftId(targetNftId);
+
+        if (! $._store.hasTokenInfo(chainId, token)) {
+            _addToken($, chainId, token);
+        }
+        
+        $._store.addTargetToken(targetNftId, token);
 
+        // TODO move logging to store
+        emit LogStakingTargetTokenAdded(targetNftId, chainId, token);
     }
 
-    function decreaseTvl(NftId targetNftId, address token, Amount amount)
+
+    /// @inheritdoc IStaking
+    function increaseTotalValueLocked(NftId targetNftId, address token, Amount amount)
         external
         virtual
-        // restricted // service to service access
+        restricted() // only pool service
     {
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.increaseTotalValueLocked(targetNftId, token, amount);
+    }
+
 
+    /// @inheritdoc IStaking
+    function decreaseTotalValueLocked(NftId targetNftId, address token, Amount amount)
+        external
+        virtual
+        restricted() // only pool service
+    {
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.decreaseTotalValueLocked(targetNftId, token, amount);
     }
 
 
+    // TODO add to interface and implement
+    /// inheritdoc IStaking
     function registerRemoteTarget(NftId targetNftId, TargetInfo memory targetInfo)
         external
         virtual
+        restricted()
         onlyOwner // or CCIP
     {
         
     }
 
+    // TODO add to interface and implement
+    /// @inheritdoc IStaking
     function updateRemoteTvl(NftId targetNftId, address token, Amount amount)
         external
         virtual
+        restricted()
         onlyOwner // or CCIP
     {
         
     }
 
-    //--- staking functions -------------------------------------------------//
+    //--- public functions --------------------------------------------------//
 
-    function registerStake(
-        NftId stakeNftId, 
-        NftId targetNftId, 
-        Amount dipAmount
-    )
+    /// @inheritdoc IStaking
+    function updateTargetLimit(NftId targetNftId)
         external
-        virtual
-        // TODO add restricted() // only staking service
+        restricted()
     {
-        Timestamp lockedUntil = StakeManagerLib.checkStakeParameters(
-            _getStakingStorage()._reader,
-            targetNftId,
-            dipAmount);
-
-        _getStakingStorage()._store.create(
-            stakeNftId, 
-            StakeInfo({
-                lockedUntil: lockedUntil}),
-            dipAmount);
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.updateTargetLimit(targetNftId);
     }
 
 
-    function stake(NftId stakeNftId, Amount dipAmount)
+    /// @inheritdoc IStaking
+    function createStake(
+        NftId targetNftId, 
+        Amount stakeAmount,
+        address stakeOwner
+    )
         external
         virtual
-        // TODO add restricted() // only staking service
-        onlyStake(stakeNftId)
+        restricted()
+        onlyTarget(targetNftId)
+        returns (NftId stakeNftId)
     {
+        // effects (includes further checks in service)
         StakingStorage storage $ = _getStakingStorage();
-        Amount rewardIncrement = StakeManagerLib.calculateRewardIncrease(
-            $._reader, 
-            stakeNftId);
+        stakeNftId = $._stakingService.createStakeObject(targetNftId, stakeOwner);
+        $._store.createStake(stakeNftId, targetNftId, stakeOwner, stakeAmount);
 
-        $._store.increaseBalance(
-            stakeNftId, 
-            dipAmount,
-            rewardIncrement);
+        // interactions
+        if (stakeAmount.gtz()) {
+            $._stakingService.pullDipToken(stakeAmount, stakeOwner);
+        }
     }
 
+    //--- stake owner functions ---------------------------------------------//
 
-    function restake(NftId stakeNftId)
+
+    /// @inheritdoc IStaking
+    function stake(
+        NftId stakeNftId, 
+        Amount stakeAmount
+    )
         external
         virtual
-        // TODO add restricted() // only staking service
-        onlyStake(stakeNftId)
+        restricted()
+        onlyStakeOwner(stakeNftId)
+        returns (Amount newStakeBalance)
     {
-        // TODO add check that target is active and allows additional staking amount
         StakingStorage storage $ = _getStakingStorage();
-        Amount rewardIncrement = StakeManagerLib.calculateRewardIncrease(
-            $._reader, 
-            stakeNftId);
-
-        $._store.restakeRewards(
+        $._store.stake(
             stakeNftId, 
-            rewardIncrement);
+            true, // update rewards
+            true, // restake rewards
+            SecondsLib.max(), // max additional locking duration
+            stakeAmount);
+
+        // collect staked DIP token via staking service
+        if (stakeAmount.gtz()) {
+            address stakeOwner = getRegistry().ownerOf(stakeNftId);
+            $._stakingService.pullDipToken(stakeAmount, stakeOwner);
+        }
     }
 
 
-    function updateRewards(NftId stakeNftId)
+    /// @inheritdoc IStaking
+    function unstake(NftId stakeNftId)
         external
         virtual
-        // TODO add restricted() // only staking service
-        onlyStake(stakeNftId)
+        restricted()
+        onlyStakeOwner(stakeNftId)
+        returns (Amount unstakedAmount)
     {
         StakingStorage storage $ = _getStakingStorage();
-        _updateRewards($._reader, $._store, stakeNftId);
+        unstakedAmount = $._store.unstake(
+            stakeNftId, 
+            true, // update rewards
+            true, // restake rewards
+            AmountLib.max()); // unstake up to this amount
+
+        // transfer unstaked DIP token via staking service
+        if (unstakedAmount.gtz()) {
+            address stakeOwner = getRegistry().ownerOf(stakeNftId);
+            $._stakingService.pushDipToken(unstakedAmount, stakeOwner);
+        }
     }
 
 
-    function claimRewards(NftId stakeNftId)
+    /// @inheritdoc IStaking
+    function restake(
+        NftId stakeNftId, 
+        NftId newTargetNftId
+    )
         external
         virtual
-        // TODO add restricted() // only staking service
-        onlyStake(stakeNftId)
+        restricted() // only staking service
+        onlyStakeOwner(stakeNftId)
+        onlyTarget(newTargetNftId)
         returns (
-            Amount rewardsClaimedAmount
+            NftId newStakeNftId,
+            Amount newStakedAmount
         )
     {
         StakingStorage storage $ = _getStakingStorage();
 
-        // update rewards since last update
-        _updateRewards($._reader, $._store, stakeNftId);
+        // step 1: unstake as much as possible
+        newStakedAmount = $._store.unstake(
+            stakeNftId, 
+            true, // update rewards
+            true, // restake rewards
+            AmountLib.max()); // unstake up to this amount
+
+        // step 2: create new stake with full unstaked amount
+        address stakeOwner = getRegistry().ownerOf(stakeNftId);
+        newStakeNftId = $._stakingService.createStakeObject(newTargetNftId, stakeOwner);
+        $._store.createStake(newStakeNftId, newTargetNftId, stakeOwner, newStakedAmount);
 
-        // unstake all available rewards
-        rewardsClaimedAmount = $._store.claimUpTo(
-            stakeNftId,
-            AmountLib.max());
+        // logging
+        emit LogStakingStakeRestaked(newStakeNftId, newTargetNftId, newStakedAmount, stakeOwner, stakeNftId);
     }
 
 
-    function unstake(NftId stakeNftId)
+    function updateRewards(NftId stakeNftId)
         external
         virtual
-        // TODO add restricted() // only staking service
-        onlyStake(stakeNftId)
-        returns (
-            Amount unstakedAmount,
-            Amount rewardsClaimedAmount
-        )
+        restricted()
+        onlyStakeOwner(stakeNftId)
+        returns (Amount newRewardAmount)
     {
-        // TODO add check that stake locking is in the past
         StakingStorage storage $ = _getStakingStorage();
-
-        // update rewards since last update
-        _updateRewards($._reader, $._store, stakeNftId);
-
-        // unstake all available dips
-        (
-            unstakedAmount, 
-            rewardsClaimedAmount
-        ) = $._store.unstakeUpTo(
-            stakeNftId,
-            AmountLib.max(), // unstake all stakes
-            AmountLib.max()); // claim all rewards
+        $._store.updateRewards(stakeNftId);
     }
 
 
-
-    function _updateRewards(
-        StakingReader reader,
-        StakingStore store,
-        NftId stakeNftId
-    )
-        internal
+    function claimRewards(NftId stakeNftId)
+        external
         virtual
+        restricted()
+        onlyStakeOwner(stakeNftId)
+        returns (
+            Amount claimedAmount
+        )
     {
-        Amount rewardIncrement = StakeManagerLib.calculateRewardIncrease(
-            reader, 
-            stakeNftId);
-
-        store.updateRewards(
+        StakingStorage storage $ = _getStakingStorage();
+        claimedAmount = $._store.claimRewards(
             stakeNftId, 
-            rewardIncrement);
+            true, 
+            AmountLib.max());
+
+        // collect staked DIP token by staking service
+        if (claimedAmount.gtz()) {
+            // interactions
+            address stakeOwner = getRegistry().ownerOf(stakeNftId);
+            $._stakingService.pushDipToken(claimedAmount, stakeOwner);
+        }
     }
 
 
-    //--- other functions ---------------------------------------------------//
+    //--- view functions ----------------------------------------------------//
 
-    function collectDipAmount(address from, Amount dipAmount)
-        external
-        // TODO add restricted() // only staking service
-    {
-        TokenHandler tokenHandler = getTokenHandler();
-        address stakingWallet = getWallet();
+    function getStakingReader() public virtual view returns (StakingReader reader) {
+        return _getStakingStorage()._reader;
+    }
+
+    function getTargetHandler() external virtual view returns (TargetHandler targetHandler) {
+        return _getStakingStorage()._targetHandler;
+    }
 
-        StakeManagerLib.checkDipBalanceAndAllowance(
-            getToken(), 
-            from, 
-            address(tokenHandler), 
-            dipAmount);
+    function getStakingStore() external virtual view returns (StakingStore stakingStore) {
+        return _getStakingStorage()._store;
+    }
 
-        tokenHandler.transfer(from, stakingWallet, dipAmount);
+    function getTokenRegistryAddress() external virtual view returns (address tokenRegistry) {
+        return address(_getStakingStorage()._tokenRegistry);
     }
 
+    function getTokenHandler() public virtual override(Component, IComponent) view returns (TokenHandler tokenHandler) {
+        return _getStakingStorage()._tokenHandler;
+    }
 
-    function transferDipAmount(address to, Amount dipAmount)
-        external
-        // TODO add restricted() // only staking service
+    // from IRegisterable
+    function getRelease()
+        public 
+        pure 
+        virtual override (IRelease, Registerable)
+        returns(VersionPart)
     {
-        TokenHandler tokenHandler = getTokenHandler();
-        address stakingWallet = getWallet();
-
-        StakeManagerLib.checkDipBalanceAndAllowance(
-            getToken(), 
-            stakingWallet, 
-            address(tokenHandler), 
-            dipAmount);
+        return VersionPartLib.toVersionPart(3);
+    }
 
-        tokenHandler.transfer(stakingWallet, to, dipAmount);
+    // from IVersionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (Component, IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(3,0,0);
     }
 
+    //--- internal functions ------------------------------------------------//
 
-    //--- view functions ----------------------------------------------------//
 
-    function getStakingReader() public view returns (StakingReader reader) {
-        return _getStakingStorage()._reader;
-    }
+    function _refillRewardReserves(NftId targetNftId, Amount dipAmount, address transferFrom)
+        internal
+        virtual
+        returns (Amount newBalance)
+    {
+        // checks + effects
+        StakingStorage storage $ = _getStakingStorage();
+        newBalance = $._store.refillRewardReserves(targetNftId, dipAmount);
 
-    function getStakingStore() external view returns (StakingStore stakingStore) {
-        return _getStakingStorage()._store;
+        // interactions
+        // collect DIP token from target owner
+        if (dipAmount.gtz()) {
+            $._stakingService.pullDipToken(dipAmount, transferFrom);
+        }
     }
 
-    function getStakingRate(uint256 chainId, address token) external view returns (UFixed stakingRate) {
-        return _getStakingStorage()._stakingRate[chainId][token];
-    }
 
-    function getTvlAmount(NftId targetNftId, address token) external view returns (Amount tvlAmount) {
-        return _getStakingStorage()._tvlAmount[targetNftId][token];
-    }
+    function _withdrawRewardReserves(NftId targetNftId, Amount dipAmount, address transferTo)
+        internal
+        virtual
+        returns (Amount newBalance)
+    {
+        // checks + effects
+        StakingStorage storage $ = _getStakingStorage();
+        newBalance = $._store.withdrawRewardReserves(targetNftId, dipAmount);
 
-    function getStakedAmount(NftId targetNftId) external view returns (Amount stakeAmount) {
-        return _getStakingStorage()._stakedAmount[targetNftId];
+        // interactions
+        // transfer DIP token to designated address
+        if (dipAmount.gtz()) {
+            $._stakingService.pushDipToken(dipAmount, transferTo);
+        }
     }
 
-    function getTokenRegistryAddress() external view returns (address tokenRegistry) {
-        return address(_getStakingStorage()._tokenRegistry);
-    }
 
-    function calculateRewardIncrementAmount(
-        NftId targetNftId,
-        Timestamp rewardsLastUpdatedAt
+    function _addToken(
+        StakingStorage storage $,
+        ChainId chainId, 
+        address token
     )
-        public 
+        internal
         virtual
-        view 
-        returns (Amount rewardIncrementAmount)
     {
-
+        $._store.addToken(chainId, token);
     }
 
-    //--- internal functions ------------------------------------------------//
 
+    /// @dev top level initializer (upgradable contract)
     function _initialize(
         address owner, 
         bytes memory data
     )
         internal
         virtual override
-        initializer
+        onlyInitializing()
     {
         (
-            address initialAuthority,
             address registryAddress,
-            address stakingReaderAddress,
+            address targetHandlerAddress,
             address stakingStoreAddress,
-            address initialOwner
-        ) = abi.decode(data, (address, address, address, address, address));
+            address tokenRegistryAddress
+        ) = abi.decode(data, (address, address, address, address));
 
+        // wiring to external contracts
         IRegistry registry = IRegistry(registryAddress);
-        TokenRegistry tokenRegistry = TokenRegistry(registry.getTokenRegistryAddress());
-        address dipTokenAddress = address(tokenRegistry.getDipToken());
-
-        initializeComponent(
-            initialAuthority,
-            registryAddress, 
-            registry.getNftId(), 
+        StakingStorage storage $ = _getStakingStorage();
+        $._protocolNftId = registry.getProtocolNftId();
+        $._targetHandler = TargetHandler(targetHandlerAddress);
+        $._store = StakingStore(stakingStoreAddress);
+        $._reader = StakingStore(stakingStoreAddress).getStakingReader();
+        $._tokenRegistry = TokenRegistry(tokenRegistryAddress);
+        // staking service has to be set via setStakingService after deploying the first GIF release
+
+        // initialize component
+        __Component_init(
+            registry.getAuthority(),
+            address(registry), 
+            registry.getNftId(), // parent nft id
             CONTRACT_NAME,
-            dipTokenAddress,
             STAKING(), 
             false, // is interceptor
-            initialOwner, 
-            "", // registry data
-            ""); // component data
+            owner, 
+            ""); // registry data
 
-        _createAndSetTokenHandler();
+        // Protocol target is created in the StakingStore constructor.
+        // This allows setting up the protocol target before the full 
+        // staking authorization setup is in place.
 
-        // wiring to external contracts
-        StakingStorage storage $ = _getStakingStorage();
-        $._protocolNftId = getRegistry().getProtocolNftId();
-        $._store = StakingStore(stakingStoreAddress);
-        $._reader = StakingReader(stakingReaderAddress);
-        $._tokenRegistry = TokenRegistry(
-            address(tokenRegistry));
+        _registerInterface(type(IStaking).interfaceId);
+    }
 
-        // wiring to staking
-        $._reader.setStakingDependencies(
-            registryAddress,
-            address(this),
-            stakingStoreAddress);
 
-        registerInterface(type(IStaking).interfaceId);
+    function _checkTypeAndOwner(NftId nftId, ObjectType expectedObjectType, bool checkOwner)
+        internal
+        view
+    {
+        StakingStorage storage $ = _getStakingStorage();
+        if (expectedObjectType == STAKE()) {
+            if (!$._store.exists(nftId)) {
+                revert ErrorStakingNotStake(nftId);
+            }
+        } else {
+            if (expectedObjectType == TARGET()) {
+                if (!$._store.getTargetSet().exists(nftId)) {
+                    revert ErrorStakingNotTarget(nftId);
+                }
+            }
+        }
+
+        if (checkOwner) {
+            address nftOwner = getRegistry().ownerOf(nftId);
+            if (msg.sender != nftOwner) {
+                revert ErrorStakingNotOwner(nftId, nftOwner, msg.sender);
+            }
+        }
     }
 
 
@@ -498,5 +794,4 @@ contract Staking is
             $.slot := STAKING_LOCATION_V1
         }
     }
-
 }