@etherisc/gif-next 0.0.2-ffa91a6-022 → 3.0.0-06d5e8b-738

package/contracts/staking/Staking.sol

@@ -6,28 +6,31 @@ import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IER
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRelease} from "../registry/IRelease.sol";
 import {IStaking} from "./IStaking.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 {IComponentService} from "../shared/IComponentService.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, STAKE, STAKING} from "../type/ObjectType.sol";
-import {Seconds} from "../type/Seconds.sol";
+import {ObjectType, PROTOCOL, INSTANCE, STAKE, STAKING, TARGET} from "../type/ObjectType.sol";
+import {Seconds, SecondsLib} from "../type/Seconds.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} 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} from "../type/UFixed.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
 import {Version, VersionLib, VersionPart, VersionPartLib} from "../type/Version.sol";
 import {Versionable} from "../upgradeability/Versionable.sol";
 
+
 contract Staking is 
     Component,
     Versionable,
@@ -41,29 +44,36 @@ contract Staking is
     struct StakingStorage {
         TokenRegistry _tokenRegistry;
         TokenHandler _tokenHandler;
+        IStakingService _stakingService;
+        TargetHandler _targetHandler;
         StakingStore _store;
         StakingReader _reader;
         NftId _protocolNftId;
     }
 
 
-    modifier onlyStake(NftId stakeNftId) {
-        if (!_getStakingStorage()._store.exists(stakeNftId)) {
-            revert ErrorStakingNotStake(stakeNftId);
-        }
+    modifier onlyStakeOwner(NftId stakeNftId) {
+        _checkTypeAndOwner(stakeNftId, STAKE(), true);
         _;
     }
 
 
     modifier onlyTarget(NftId targetNftId) {
-        if (!_getStakingStorage()._store.getTargetNftIdSet().exists(targetNftId)) {
-            revert ErrorStakingNotTarget(targetNftId);
-        }
+        _checkTypeAndOwner(targetNftId, TARGET(), false);
+        _;
+    }
+
+
+    modifier onlyTargetOwner(NftId targetNftId) {
+        _checkTypeAndOwner(targetNftId, TARGET(), true);
         _;
     }
 
+    //--- contract intitialization -------------------------------------------
+
     function initializeTokenHandler()
         external
+        virtual
     {
         if (msg.sender != address(getRegistry())) {
             revert ErrorStakingNotRegistry(msg.sender);
@@ -79,79 +89,272 @@ contract Staking is
     }
 
 
-    function approveTokenHandler(IERC20Metadata token, Amount amount)
-        public
+    //--- 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()
     {
-        _approveTokenHandler(token, amount);
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.setLockingPeriod($._protocolNftId, newLockingPeriod);
     }
 
 
-    // set/update staking reader
-    function setStakingReader(StakingReader stakingReader)
+    /// @inheritdoc IStaking
+    function setProtocolRewardRate(UFixed newRewardRate)
         external
         virtual
+        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
+        restricted()
+        onlyOwner()
+    {
+        _addToken(
+            _getStakingStorage(), chainId, token);
+    }
+
+
+    /// @inheritdoc IStaking
+    function approveTokenHandler(IERC20Metadata token, Amount amount)
+        public
+        virtual
+        restricted()
         onlyOwner()
     {
         StakingStorage storage $ = _getStakingStorage();
-        
-        if (!$._tokenRegistry.isRegistered(chainId, token)) {
-            revert ErrorStakingTokenNotRegistered(chainId, token);
+        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);
+    }
+
+    //--- 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);
+    }
+
+
+    /// @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");
         }
 
-        UFixed oldStakingRate = $._store.getStakingRate(chainId, token);
-        $._store.setStakingRate(chainId, token, stakingRate);
+        newBalance = _withdrawRewardReserves(targetNftId, dipAmount, transferTo);
+    }
+
 
-        emit LogStakingStakingRateSet(chainId, token, oldStakingRate, stakingRate);
+    /// @inheritdoc IStaking
+    function refillRewardReservesByService(NftId targetNftId, Amount dipAmount, address transferFrom)
+        external
+        virtual
+        restricted()
+        onlyTarget(targetNftId)
+        returns (Amount newBalance)
+    {
+        _refillRewardReserves(targetNftId, dipAmount, transferFrom);
     }
 
-    // target management
 
+    /// @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()
+        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,
-                maxStakedAmount: AmountLib.max()}));
+            expectedObjectType,
+            initialLockingPeriod,
+            initialRewardRate);
     }
 
 
+    /// @inheritdoc IStaking
     function setLockingPeriod(
         NftId targetNftId, 
         Seconds lockingPeriod
@@ -161,107 +364,91 @@ contract Staking is
         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
         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 setMaxStakedAmount(NftId targetNftId, Amount maxStakedAmount)
+
+    // TODO refactor into setTargetLimits
+    /// @inheritdoc IStaking
+    function setMaxStakedAmount(NftId targetNftId, Amount stakeLimitAmount)
         external
         virtual
         restricted()
         onlyTarget(targetNftId)
     {
-        IStaking.TargetInfo memory targetInfo = getStakingReader().getTargetInfo(targetNftId);
-
-        targetInfo.maxStakedAmount = maxStakedAmount;
-        
-        _getStakingStorage()._store.updateTarget(targetNftId, targetInfo);
-
-        emit LogStakingMaxStakedAmountSet(targetNftId, maxStakedAmount);
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.setMaxStakedAmount(targetNftId, stakeLimitAmount);
     }
 
 
-    function refillRewardReserves(NftId targetNftId, Amount dipAmount)
+    /// @inheritdoc IStaking
+    function setTargetLimits(NftId targetNftId, Amount marginAmount, Amount limitAmount)
         external
         virtual
         restricted()
-        returns (Amount newBalance)
+        onlyTargetOwner(targetNftId)
     {
-        // update book keeping of reward reserves
         StakingStorage storage $ = _getStakingStorage();
-        newBalance = $._store.increaseReserves(targetNftId, dipAmount);
+        $._store.setTargetLimits(targetNftId, marginAmount, limitAmount);
     }
 
 
-    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount)
+    /// @inheritdoc IStaking
+    function addTargetToken(NftId targetNftId, address token)
         external
         virtual
         restricted()
-        returns (Amount newBalance)
+        onlyTarget(targetNftId)
     {
-        // update book keeping of reward reserves
         StakingStorage storage $ = _getStakingStorage();
-        newBalance = $._store.decreaseReserves(targetNftId, dipAmount);
+        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);
     }
 
 
+    /// @inheritdoc IStaking
     function increaseTotalValueLocked(NftId targetNftId, address token, Amount amount)
         external
         virtual
         restricted() // only pool service
-        returns (Amount newBalance)
     {
         StakingStorage storage $ = _getStakingStorage();
-        uint chainId = $._reader.getTargetInfo(targetNftId).chainId;
-        UFixed stakingRate = $._reader.getStakingRate(chainId, token);
-        newBalance = $._store.increaseTotalValueLocked(targetNftId, stakingRate, token, amount);
+        $._store.increaseTotalValueLocked(targetNftId, token, amount);
     }
 
 
+    /// @inheritdoc IStaking
     function decreaseTotalValueLocked(NftId targetNftId, address token, Amount amount)
         external
         virtual
         restricted() // only pool service
-        returns (Amount newBalance)
     {
         StakingStorage storage $ = _getStakingStorage();
-        uint chainId = $._reader.getTargetInfo(targetNftId).chainId;
-        UFixed stakingRate = $._reader.getStakingRate(chainId, token);
-        newBalance = $._store.decreaseTotalValueLocked(targetNftId, stakingRate, token, amount);
+        $._store.decreaseTotalValueLocked(targetNftId, token, amount);
     }
 
 
+    // TODO add to interface and implement
+    /// inheritdoc IStaking
     function registerRemoteTarget(NftId targetNftId, TargetInfo memory targetInfo)
         external
         virtual
@@ -271,6 +458,8 @@ contract Staking is
         
     }
 
+    // TODO add to interface and implement
+    /// @inheritdoc IStaking
     function updateRemoteTvl(NftId targetNftId, address token, Amount amount)
         external
         virtual
@@ -280,158 +469,179 @@ contract Staking is
         
     }
 
-    //--- staking functions -------------------------------------------------//
+    //--- public functions --------------------------------------------------//
+
+    /// @inheritdoc IStaking
+    function updateTargetLimit(NftId targetNftId)
+        external
+        restricted()
+    {
+        StakingStorage storage $ = _getStakingStorage();
+        $._store.updateTargetLimit(targetNftId);
+    }
+
 
+    /// @inheritdoc IStaking
     function createStake(
-        NftId stakeNftId, 
         NftId targetNftId, 
-        Amount stakeAmount
+        Amount stakeAmount,
+        address stakeOwner
     )
         external
         virtual
-        restricted() // only staking service
+        restricted()
+        onlyTarget(targetNftId)
+        returns (NftId stakeNftId)
     {
+        // effects (includes further checks in service)
         StakingStorage storage $ = _getStakingStorage();
-        Timestamp lockedUntil = StakingLib.checkCreateParameters(
-            $._reader,
-            targetNftId,
-            stakeAmount);
+        stakeNftId = $._stakingService.createStakeObject(targetNftId, stakeOwner);
+        $._store.createStake(stakeNftId, targetNftId, stakeOwner, stakeAmount);
 
-        // create new stake
-        $._store.create(
-            stakeNftId, 
-            StakeInfo({
-                lockedUntil: lockedUntil}));
-        
-        // update target stake balance
-        $._store.increaseStake(
-            stakeNftId,
-            targetNftId, 
-            stakeAmount);
+        // interactions
+        if (stakeAmount.gtz()) {
+            $._stakingService.pullDipToken(stakeAmount, stakeOwner);
+        }
     }
 
+    //--- stake owner functions ---------------------------------------------//
+
 
+    /// @inheritdoc IStaking
     function stake(
         NftId stakeNftId, 
         Amount stakeAmount
     )
         external
         virtual
-        restricted() // only staking service
-        onlyStake(stakeNftId)
-        returns (Amount stakeBalance)
+        restricted()
+        onlyStakeOwner(stakeNftId)
+        returns (Amount newStakeBalance)
     {
         StakingStorage storage $ = _getStakingStorage();
-        stakeBalance = StakingLib.stake(
-            getRegistry(),
-            $._reader,
-            $._store,
-            stakeNftId,
+        $._store.stake(
+            stakeNftId, 
+            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 restake(
-        NftId stakeNftId, 
-        NftId newStakeNftId
-    )
+    /// @inheritdoc IStaking
+    function unstake(NftId stakeNftId)
         external
         virtual
-        restricted() // only staking service
-        onlyStake(stakeNftId)
-        returns (Amount newStakeBalance)
+        restricted()
+        onlyStakeOwner(stakeNftId)
+        returns (Amount unstakedAmount)
     {
-        _checkNftType(stakeNftId, STAKE());
-        _checkNftType(newStakeNftId, STAKE());
-
-        // TODO add check that allows additional staking amount
         StakingStorage storage $ = _getStakingStorage();
-        newStakeBalance = StakingLib.restake(
-            $._reader,
-            $._store,
-            stakeNftId,
-            newStakeNftId);    
+        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 updateRewards(NftId stakeNftId)
+
+    /// @inheritdoc IStaking
+    function restake(
+        NftId stakeNftId, 
+        NftId newTargetNftId
+    )
         external
         virtual
         restricted() // only staking service
-        onlyStake(stakeNftId)
+        onlyStakeOwner(stakeNftId)
+        onlyTarget(newTargetNftId)
+        returns (
+            NftId newStakeNftId,
+            Amount newStakedAmount
+        )
     {
         StakingStorage storage $ = _getStakingStorage();
-        _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);
+
+        // logging
+        emit LogStakingStakeRestaked(newStakeNftId, newTargetNftId, newStakedAmount, stakeOwner, stakeNftId);
     }
 
 
-    function claimRewards(NftId stakeNftId)
+    function updateRewards(NftId stakeNftId)
         external
         virtual
-        restricted() // only staking service
-        onlyStake(stakeNftId)
-        returns (
-            Amount rewardsClaimedAmount
-        )
+        restricted()
+        onlyStakeOwner(stakeNftId)
+        returns (Amount newRewardAmount)
     {
         StakingStorage storage $ = _getStakingStorage();
-
-        // update rewards since last update
-        NftId targetNftId = _updateRewards($._reader, $._store, stakeNftId);
-
-        // unstake all available rewards
-        rewardsClaimedAmount = $._store.claimUpTo(
-            stakeNftId,
-            targetNftId, 
-            AmountLib.max());
-
-        // update reward reserves
-        $._store.decreaseReserves(targetNftId, rewardsClaimedAmount);
+        $._store.updateRewards(stakeNftId);
     }
 
 
-    function unstake(NftId stakeNftId)
+    function claimRewards(NftId stakeNftId)
         external
         virtual
-        restricted() // only staking service
-        onlyStake(stakeNftId)
+        restricted()
+        onlyStakeOwner(stakeNftId)
         returns (
-            Amount unstakedAmount,
-            Amount rewardsClaimedAmount
+            Amount claimedAmount
         )
     {
         StakingStorage storage $ = _getStakingStorage();
-        
-        StakingLib.checkUnstakeParameters($._reader, stakeNftId);
-        
-        // update rewards since last update
-        NftId targetNftId = _updateRewards($._reader, $._store, stakeNftId);
-
-        // unstake all available dips
-        (
-            unstakedAmount, 
-            rewardsClaimedAmount
-        ) = $._store.unstakeUpTo(
-            stakeNftId,
-            targetNftId,
-            AmountLib.max(), // unstake all stakes
-            AmountLib.max()); // claim all rewards
+        claimedAmount = $._store.claimRewards(
+            stakeNftId, 
+            true, 
+            AmountLib.max());
 
-        // update reward reserves
-        $._store.decreaseReserves(targetNftId, rewardsClaimedAmount);
+        // collect staked DIP token by staking service
+        if (claimedAmount.gtz()) {
+            // interactions
+            address stakeOwner = getRegistry().ownerOf(stakeNftId);
+            $._stakingService.pushDipToken(claimedAmount, stakeOwner);
+        }
     }
 
 
     //--- view functions ----------------------------------------------------//
 
-    function getStakingReader() public view returns (StakingReader reader) {
+    function getStakingReader() public virtual view returns (StakingReader reader) {
         return _getStakingStorage()._reader;
     }
 
-    function getStakingStore() external view returns (StakingStore stakingStore) {
+    function getTargetHandler() external virtual view returns (TargetHandler targetHandler) {
+        return _getStakingStorage()._targetHandler;
+    }
+
+    function getStakingStore() external virtual view returns (StakingStore stakingStore) {
         return _getStakingStorage()._store;
     }
 
-    function getTokenRegistryAddress() external view returns (address tokenRegistry) {
+    function getTokenRegistryAddress() external virtual view returns (address tokenRegistry) {
         return address(_getStakingStorage()._tokenRegistry);
     }
 
@@ -461,83 +671,124 @@ contract Staking is
 
     //--- internal functions ------------------------------------------------//
 
-    function _updateRewards(
-        StakingReader reader,
-        StakingStore store,
-        NftId stakeNftId
-    )
+
+    function _refillRewardReserves(NftId targetNftId, Amount dipAmount, address transferFrom)
         internal
         virtual
-        returns (NftId targetNftId)
+        returns (Amount newBalance)
     {
-        UFixed rewardRate;
+        // checks + effects
+        StakingStorage storage $ = _getStakingStorage();
+        newBalance = $._store.refillRewardReserves(targetNftId, dipAmount);
 
-        (targetNftId, rewardRate) = reader.getTargetRewardRate(stakeNftId);
-        (Amount rewardIncrement, ) = StakingLib.calculateRewardIncrease(
-            reader, 
-            stakeNftId,
-            rewardRate);
+        // interactions
+        // collect DIP token from target owner
+        if (dipAmount.gtz()) {
+            $._stakingService.pullDipToken(dipAmount, transferFrom);
+        }
+    }
 
-        store.updateRewards(
-            stakeNftId, 
-            targetNftId,
-            rewardIncrement);
+
+    function _withdrawRewardReserves(NftId targetNftId, Amount dipAmount, address transferTo)
+        internal
+        virtual
+        returns (Amount newBalance)
+    {
+        // checks + effects
+        StakingStorage storage $ = _getStakingStorage();
+        newBalance = $._store.withdrawRewardReserves(targetNftId, dipAmount);
+
+        // interactions
+        // transfer DIP token to designated address
+        if (dipAmount.gtz()) {
+            $._stakingService.pushDipToken(dipAmount, transferTo);
+        }
     }
 
 
-    function _approveTokenHandler(IERC20Metadata token, Amount amount)
+    function _addToken(
+        StakingStorage storage $,
+        ChainId chainId, 
+        address token
+    )
         internal
-        virtual override
+        virtual
     {
-        IComponentService(_getServiceAddress(STAKING())).approveTokenHandler(
-            token, 
-            amount);
+        $._store.addToken(chainId, token);
     }
 
 
+    /// @dev top level initializer (upgradable contract)
     function _initialize(
         address owner, 
         bytes memory data
     )
         internal
         virtual override
-        initializer()
+        onlyInitializing()
     {
         (
             address registryAddress,
-            address tokenRegistryAddress,
+            address targetHandlerAddress,
             address stakingStoreAddress,
-            address stakingOwner
+            address tokenRegistryAddress
         ) = abi.decode(data, (address, address, address, address));
 
-        // only admin(authority) and dip token address are set in registry at this point
-        IRegistry registry = IRegistry(registryAddress);
-        address authority = registry.getAuthority();
-        TokenRegistry tokenRegistry = TokenRegistry(tokenRegistryAddress);
-        address dipTokenAddress = tokenRegistry.getDipTokenAddress();
-
         // wiring to external contracts
+        IRegistry registry = IRegistry(registryAddress);
         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
 
-        _initializeComponent(
-            authority,
-            registryAddress, 
+        // initialize component
+        __Component_init(
+            registry.getAuthority(),
+            address(registry), 
             registry.getNftId(), // parent nft id
             CONTRACT_NAME,
             STAKING(), 
             false, // is interceptor
-            stakingOwner, 
-            "", // registry data
-            ""); // component data
+            owner, 
+            ""); // registry data
+
+        // Protocol target is created in the StakingStore constructor.
+        // This allows setting up the protocol target before the full 
+        // staking authorization setup is in place.
 
         _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);
+            }
+        }
+    }
+
+
     function _getStakingStorage() private pure returns (StakingStorage storage $) {
         assembly {
             $.slot := STAKING_LOCATION_V1