@etherisc/gif-next 0.0.2-85cbb88-630 → 0.0.2-85e1eb3-876

package/contracts/staking/Staking.sol

@@ -1,27 +1,36 @@
 // 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 {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType, INSTANCE, PROTOCOL, STAKE, STAKING, TARGET} from "../type/ObjectType.sol";
+import {IStakingService} from "./IStakingService.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, COMPONENT, 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 {ReleaseRegistry} from "../registry/ReleaseRegistry.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 {Timestamp} from "../type/Timestamp.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 {UFixed} from "../type/UFixed.sol";
+import {Version, VersionLib, VersionPart, VersionPartLib} from "../type/Version.sol";
+import {Versionable} from "../upgradeability/Versionable.sol";
 
 contract Staking is 
     Component,
@@ -29,14 +38,14 @@ 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;
         StakingStore _store;
         StakingReader _reader;
         NftId _protocolNftId;
@@ -44,83 +53,289 @@ contract Staking is
 
 
     modifier onlyStake(NftId stakeNftId) {
-        if (!_getStakingStorage()._store.exists(stakeNftId)) {
-            revert ErrorStakingNotStake(stakeNftId);
-        }
+        _checkTypeAndOwner(stakeNftId, STAKE(), false);
+        _;
+    }
+
+
+    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);
         _;
     }
 
-    // set/update staking reader
+    //--- contract intitialization -------------------------------------------
+
+    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());
+    }
+
+    //--- staking owner functions -------------------------------------------//
+
+    // TODO also make sure that protocol rewards can be refilled and withdrawn
+
+    /// @inheritdoc IStaking
+    function setProtocolLockingPeriod(Seconds newLockingPeriod)
+        external
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        NftId protocolNftId = getRegistry().getProtocolNftId();
+        (
+            Seconds oldLockingPeriod,
+            Blocknumber lastUpdatedIn
+        ) = _getStakingStorage()._store.setLockingPeriod(protocolNftId, newLockingPeriod);
+
+        emit LogStakingProtocolLockingPeriodSet(protocolNftId, newLockingPeriod, oldLockingPeriod, lastUpdatedIn);
+    }
+
+
+    /// @inheritdoc IStaking
+    function setProtocolRewardRate(UFixed newRewardRate)
+        external
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        NftId protocolNftId = getRegistry().getProtocolNftId();        
+        (
+            UFixed oldRewardRate,
+            Blocknumber lastUpdatedIn
+        ) = _getStakingStorage()._store.setRewardRate(protocolNftId, newRewardRate);
+
+        emit LogStakingProtocolRewardRateSet(protocolNftId, newRewardRate, oldRewardRate, lastUpdatedIn);
+    }
+
+
+    /// @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()
+    {
+        // checks
+        if (!ReleaseRegistry(getRegistry().getReleaseRegistryAddress()).isActiveRelease(release)) {
+            revert ErrorStakingReleaseNotActive(release);
+        }
+
+        address stakingServiceAddress = getRegistry().getServiceAddress(STAKING(), release);
+        if (stakingServiceAddress == address(0)) {
+            revert ErrorStakingServiceNotFound(release);
+        }
+
+        // effects
+        address oldStakingService = address(_getStakingStorage()._stakingService);
+        _getStakingStorage()._stakingService = IStakingService(stakingServiceAddress);
+
+        emit LogStakingStakingServiceSet(stakingServiceAddress, release, oldStakingService);
+    }
+
+
+    /// @inheritdoc IStaking
     function setStakingReader(StakingReader stakingReader)
         external
         virtual
+        restricted()
         onlyOwner()
     {
         if(stakingReader.getStaking() != IStaking(this)) {
             revert ErrorStakingStakingReaderStakingMismatch(address(stakingReader.getStaking()));
         }
 
+        address oldReader = address(_getStakingStorage()._reader);
         _getStakingStorage()._reader = stakingReader;
+
+        emit LogStakingStakingReaderSet(address(stakingReader), oldReader);
     }
 
 
-    // rate management 
-    function setStakingRate(uint256 chainId, address token, UFixed stakingRate)
+    /// @inheritdoc IStaking
+    function addToken(
+        ChainId chainId, 
+        address token
+    )
         external
         virtual
+        restricted()
         onlyOwner()
     {
-        StakingStorage storage $ = _getStakingStorage();
-        
-        if (!$._tokenRegistry.isRegistered(chainId, token)) {
-            revert ErrorStakingTokenNotRegistered(chainId, token);
+        _addToken(
+            _getStakingStorage(), chainId, token);
+    }
+
+
+    /// @inheritdoc IStaking
+    function approveTokenHandler(IERC20Metadata token, Amount amount)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        Amount oldAllowanceAmount = AmountLib.toAmount(
+            token.allowance(
+                address(this), 
+                address(_getStakingStorage()._tokenHandler)));
+
+        // staking token handler approval via its own implementation in staking service
+        IComponentService(_getServiceAddress(STAKING())).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)
+    {
+        // special case 1: protocol target: staking owner is recipient
+        if (targetNftId == getRegistry().getProtocolNftId()) {
+            // verify that the caller is the staking owner
+            if (msg.sender != getOwner()) {
+                revert ErrorStakingNotStakingOwner();
+            }
+
+            return _withdrawRewardReserves(targetNftId, dipAmount, getOwner());
+        }
+
+        // special case 2: off-chain targets
+        // TODO decide how to handle and implement
+
+        // default: on-chain target owner is recipient
+        address targetOwner = getRegistry().ownerOf(targetNftId);
+        // verify that the caller is the target owner
+        if (msg.sender != targetOwner) {
+            revert ErrorStakingNotNftOwner(targetNftId);
+        }
+
+        return _withdrawRewardReserves(targetNftId, dipAmount, targetOwner);
+    }
+
+
+    /// @inheritdoc IStaking
+    function refillRewardReservesByService(NftId targetNftId, Amount dipAmount, address transferFrom)
+        external
+        virtual
+        restricted()
+        onlyTarget(targetNftId)
+        returns (Amount newBalance)
+    {
+        address fundingBy = msg.sender;
+        _refillRewardReserves(targetNftId, dipAmount, transferFrom);
+    }
+
+
+    /// @inheritdoc IStaking
+    function withdrawRewardReservesByService(NftId targetNftId, Amount dipAmount, address transferTo)
+        external
+        virtual
+        restricted()
+        onlyTarget(targetNftId)
+        returns (Amount newBalance)
+    {
+        // special case 1: protocol target: staking owner is recipient
+        if (targetNftId == getRegistry().getProtocolNftId()) {
+            return _withdrawRewardReserves(targetNftId, dipAmount, transferTo);
         }
 
-        UFixed oldStakingRate = $._store.getStakingRate(chainId, token);
-        $._store.setStakingRate(chainId, token, stakingRate);
+        // special case 2: off-chain targets
+        // TODO decide how to handle and implement
 
-        emit LogStakingStakingRateSet(chainId, token, oldStakingRate, stakingRate);
+        // default: on-chain target owner is recipient
+        address targetOwner = getRegistry().ownerOf(targetNftId);
+        return _withdrawRewardReserves(targetNftId, dipAmount, targetOwner);
     }
 
-    // target management
 
+    /// @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}));
+            expectedObjectType,
+            initialLockingPeriod,
+            initialRewardRate);
+
+        emit LogStakingTargetCreated(targetNftId, expectedObjectType, initialLockingPeriod, initialRewardRate, AmountLib.max());
     }
 
 
+    /// @inheritdoc IStaking
     function setLockingPeriod(
         NftId targetNftId, 
         Seconds lockingPeriod
@@ -130,66 +345,76 @@ contract Staking is
         restricted()
         onlyTarget(targetNftId)
     {
-        (
-            Seconds oldLockingPeriod,
-            TargetInfo memory targetInfo
-        ) = TargetManagerLib.updateLockingPeriod(
-            this,
-            targetNftId,
-            lockingPeriod);
-        
-        _getStakingStorage()._store.updateTarget(targetNftId, targetInfo);
+        (Seconds oldLockingPeriod, ) = _getStakingStorage()._store.setLockingPeriod(targetNftId, lockingPeriod);
 
-        emit LogStakingLockingPeriodSet(targetNftId, oldLockingPeriod, lockingPeriod);
+        emit LogStakingTargetLockingPeriodSet(targetNftId, lockingPeriod, oldLockingPeriod);
     }
 
-    // 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);
+        (UFixed oldRewardRate,) = _getStakingStorage()._store.setRewardRate(targetNftId, rewardRate);
+        emit LogStakingTargetRewardRateSet(targetNftId, rewardRate, oldRewardRate);
     }
 
 
-    function refillRewardReserves(NftId targetNftId, Amount dipAmount)
+    /// @inheritdoc IStaking
+    function setMaxStakedAmount(NftId targetNftId, Amount maxStakedAmount)
         external
         virtual
         restricted()
-        returns (Amount newBalance)
+        onlyTarget(targetNftId)
     {
-        // update book keeping of reward reserves
-        StakingStorage storage $ = _getStakingStorage();
-        newBalance = $._store.increaseReserves(targetNftId, dipAmount);
+        _getStakingStorage()._store.setMaxStakedAmount(targetNftId, maxStakedAmount);
+        emit LogStakingTargetMaxStakedAmountSet(targetNftId, maxStakedAmount);
     }
 
-
-    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount)
+    // TODO cleanup
+    // /// @inheritdoc IStaking
+    // function refillRewardReservesByService(NftId targetNftId, Amount dipAmount, address from)
+    //     external
+    //     virtual
+    //     restricted()
+    //     returns (Amount newBalance)
+    // {
+    //     _refillRewardReserves(targetNftId, dipAmount, from);
+    // }
+
+
+    // /// @inheritdoc IStaking
+    // function withdrawRewardReservesByService(NftId targetNftId, Amount dipAmount, address to)
+    //     external
+    //     virtual
+    //     restricted()
+    //     returns (Amount newBalance)
+    // {
+    //     _withdrawRewardReserves(targetNftId, dipAmount, to);
+    // }
+
+
+    /// @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);
+        _addToken($, chainId, token);
+        
+        $._store.addTargetToken(targetNftId, token);
+
+        emit LogStakingTargetTokenAdded(targetNftId, chainId, token);
     }
 
 
+    /// @inheritdoc IStaking
     function increaseTotalValueLocked(NftId targetNftId, address token, Amount amount)
         external
         virtual
@@ -197,12 +422,13 @@ contract Staking is
         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);
+        newBalance = $._store.increaseTotalValueLocked(targetNftId, token, amount);
+
+        emit LogStakingTotalValueLockedIncreased(targetNftId, token, amount, newBalance);
     }
 
 
+    /// @inheritdoc IStaking
     function decreaseTotalValueLocked(NftId targetNftId, address token, Amount amount)
         external
         virtual
@@ -210,12 +436,14 @@ contract Staking is
         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);
+        newBalance = $._store.decreaseTotalValueLocked(targetNftId, token, amount);
+
+        emit LogStakingTotalValueLockedDecreased(targetNftId, token, amount, newBalance);
     }
 
 
+    // TODO add to interface and implement
+    /// inheritdoc IStaking
     function registerRemoteTarget(NftId targetNftId, TargetInfo memory targetInfo)
         external
         virtual
@@ -225,6 +453,8 @@ contract Staking is
         
     }
 
+    // TODO add to interface and implement
+    /// @inheritdoc IStaking
     function updateRemoteTvl(NftId targetNftId, address token, Amount amount)
         external
         virtual
@@ -236,270 +466,451 @@ contract Staking is
 
     //--- staking functions -------------------------------------------------//
 
+    /// @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)
     {
         StakingStorage storage $ = _getStakingStorage();
-        Timestamp lockedUntil = StakeManagerLib.checkCreateParameters(
-            $._reader,
-            targetNftId,
-            stakeAmount);
 
-        // create new stake
-        $._store.create(
-            stakeNftId, 
-            StakeInfo({
-                lockedUntil: lockedUntil}));
-        
-        // update target stake balance
-        $._store.increaseStake(
-            stakeNftId,
-            targetNftId, 
-            stakeAmount);
+        // effects (includes further checks in service)
+        stakeNftId = $._stakingService.createStakeObject(targetNftId, stakeOwner);
+        Timestamp lockedUntil = $._store.createStake(stakeNftId, targetNftId, stakeAmount);
+
+        emit LogStakingStakeCreated(stakeNftId, targetNftId, stakeAmount, lockedUntil, stakeOwner);
+
+        // interactions
+        $._stakingService.pullDipToken(stakeAmount, stakeOwner);
     }
 
 
+    /// @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 = StakeManagerLib.stake(
-            getRegistry(),
-            $._reader,
-            $._store,
-            stakeNftId,
-            stakeAmount);
-    }
 
+        // update rewards for stake (add rewards since last update)
+        (
+            Amount rewardIncreaseAmount,
+            Seconds targetLockingPeriod,
+            Amount stakeBalance,
+            Amount rewardBalance,
+            Timestamp lockedUntil
+        ) = _updateRewards($, stakeNftId);
+
+        // no additional locking duration if no additional stakes
+        if (stakeAmount.eqz()) {
+            targetLockingPeriod = SecondsLib.zero();
+        }
 
-    function restake(
-        NftId stakeNftId, 
-        NftId newTargetNftId
-    )
-        external
-        virtual
-        restricted() // only staking service
-        onlyStake(stakeNftId)
-        returns (NftId newStakeNftId)
-    {
-        // TODO add check that allows additional staking amount
-        StakingStorage storage $ = _getStakingStorage();
+        // increase stakes and restake rewards
+        bool restakeRewards = true;
+        if (restakeRewards && rewardBalance.gtz()) {
+            emit LogStakingRewardsRestaked(stakeNftId, rewardBalance + rewardBalance, stakeBalance, AmountLib.zero(), lockedUntil);
+        } 
 
-        // TODO implement
-   }
+        (
+            stakeBalance,
+            rewardBalance,
+            lockedUntil
+        ) = $._store.increaseStakes(
+            stakeNftId,
+            stakeAmount,
+            targetLockingPeriod,
+            restakeRewards); 
 
+        // collect staked DIP token by staking service
+        if (stakeAmount.gtz()) {
+            emit LogStakingStaked(stakeNftId, stakeAmount, stakeBalance, rewardBalance, lockedUntil);
 
-    function updateRewards(NftId stakeNftId)
-        external
-        virtual
-        restricted() // only staking service
-        onlyStake(stakeNftId)
-    {
-        StakingStorage storage $ = _getStakingStorage();
-        _updateRewards($._reader, $._store, stakeNftId);
+            // interactions
+            address stakeOwner = getRegistry().ownerOf(stakeNftId);
+            $._stakingService.pullDipToken(stakeAmount, stakeOwner);
+        }
     }
 
 
-    function claimRewards(NftId stakeNftId)
+    /// @inheritdoc IStaking
+    function unstake(NftId stakeNftId)
         external
         virtual
         restricted() // only staking service
-        onlyStake(stakeNftId)
+        onlyStakeOwner(stakeNftId)
         returns (
+            Amount unstakedAmount,
             Amount rewardsClaimedAmount
         )
     {
         StakingStorage storage $ = _getStakingStorage();
+        bool restakeRewards = true;
+        Timestamp lockedUntil;
 
-        // update rewards since last update
-        NftId targetNftId = _updateRewards($._reader, $._store, stakeNftId);
-
-        // unstake all available rewards
-        rewardsClaimedAmount = $._store.claimUpTo(
+        (
+            unstakedAmount,
+            rewardsClaimedAmount,
+            lockedUntil
+        ) = _unstakeAll(
+            $, 
             stakeNftId,
-            targetNftId, 
-            AmountLib.max());
+            restakeRewards); // restake rewards
 
-        // update reward reserves
-        $._store.decreaseReserves(targetNftId, rewardsClaimedAmount);
+        // collect staked DIP token by staking service
+        Amount collectedAmount = unstakedAmount + rewardsClaimedAmount;
+        if (collectedAmount.gtz()) {
+
+            // interactions
+            address stakeOwner = getRegistry().ownerOf(stakeNftId);
+            $._stakingService.pushDipToken(collectedAmount, stakeOwner);
+        }
     }
 
 
-    function unstake(NftId stakeNftId)
+    /// @inheritdoc IStaking
+    function restake(
+        NftId stakeNftId, 
+        NftId newTargetNftId
+    )
         external
         virtual
         restricted() // only staking service
-        onlyStake(stakeNftId)
+        onlyStakeOwner(stakeNftId)
+        onlyTarget(newTargetNftId)
         returns (
-            Amount unstakedAmount,
-            Amount rewardsClaimedAmount
+            NftId newStakeNftId,
+            Amount newStakedAmount
         )
     {
-        // TODO add check that stake locking is in the past
         StakingStorage storage $ = _getStakingStorage();
+        address stakeOwner = msg.sender;
 
-        // 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
-
-        // update reward reserves
-        $._store.decreaseReserves(targetNftId, rewardsClaimedAmount);
-    }
+            Amount unstakedAmount,
+            Amount rewardsClaimedAmount,
+        ) = _unstakeAll($, stakeNftId, true); // restake rewards
 
+        newStakeNftId = $._stakingService.createStakeObject(newTargetNftId, stakeOwner);
+        newStakedAmount = unstakedAmount + rewardsClaimedAmount;
+        $._store.createStake(
+            newStakeNftId, 
+            newTargetNftId, 
+            newStakedAmount);
 
+        emit LogStakingStakeRestaked(newStakeNftId, newTargetNftId, newStakedAmount, stakeOwner, stakeNftId);
+    }
 
-    //--- other functions ---------------------------------------------------//
 
-    function collectDipAmount(address from, Amount dipAmount)
+    function updateRewards(NftId stakeNftId)
         external
+        virtual
         restricted() // only staking service
+        onlyStake(stakeNftId)
+        returns (Amount newRewardAmount)
     {
-        TokenHandler tokenHandler = getTokenHandler();
-        address stakingWallet = getWallet();
-
-        StakeManagerLib.checkDipBalanceAndAllowance(
-            getToken(), 
-            from, 
-            address(tokenHandler), 
-            dipAmount);
-
-        tokenHandler.transfer(from, stakingWallet, dipAmount);
+        _updateRewards(
+            _getStakingStorage(), 
+            stakeNftId);
     }
 
 
-    function transferDipAmount(address to, Amount dipAmount)
+    function claimRewards(NftId stakeNftId)
         external
+        virtual
         restricted() // only staking service
+        onlyStake(stakeNftId)
+        returns (
+            Amount rewardsClaimedAmount
+        )
     {
-        TokenHandler tokenHandler = getTokenHandler();
-        address stakingWallet = getWallet();
+        StakingStorage storage $ = _getStakingStorage();
+
+        // update rewards since last update
+        _updateRewards($, stakeNftId);
+
+        (
+            Amount restakedRewardAmount,
+            Amount unstakedAmount,
+            Amount claimedAmount,
+            Amount stakedBalance,
+            Amount rewardBalance,
+            Timestamp lockedUntil
+        ) = $._store.decreaseStakes(
+            stakeNftId,
+            AmountLib.zero(), // unstake dip amount
+            AmountLib.max(), // unstake reward amount
+            false); // restake rewards
 
-        StakeManagerLib.checkDipBalanceAndAllowance(
-            getToken(), 
-            stakingWallet, 
-            address(tokenHandler), 
-            dipAmount);
+        // collect staked DIP token by staking service
+        if (claimedAmount.gtz()) {
+            emit LogStakingRewardsClaimed(stakeNftId, claimedAmount, stakedBalance, rewardBalance, lockedUntil);
 
-        tokenHandler.transfer(stakingWallet, to, dipAmount);
+            // 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 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);
     }
 
+    function getTokenHandler() public virtual override(Component, IComponent) view returns (TokenHandler tokenHandler) {
+        return _getStakingStorage()._tokenHandler;
+    }
 
-    // from Versionable
+    // from IRegisterable
+    function getRelease()
+        public 
+        pure 
+        virtual override (IRelease, Registerable)
+        returns(VersionPart)
+    {
+        return VersionPartLib.toVersionPart(3);
+    }
+
+    // from IVersionable
     function getVersion()
         public 
         pure 
-        virtual override (IVersionable, Versionable)
+        virtual override (Component, IVersionable, Versionable)
         returns(Version)
     {
-        return VersionLib.toVersion(GIF_MAJOR_VERSION,0,0);
+        return VersionLib.toVersion(3,0,0);
     }
 
     //--- internal functions ------------------------------------------------//
 
+
+    function _refillRewardReserves(NftId targetNftId, Amount dipAmount, address transferFrom)
+        internal
+        virtual
+        returns (Amount newBalance)
+    {
+        // checks + effects
+        StakingStorage storage $ = _getStakingStorage();
+        newBalance = $._store.refillRewardReserves(targetNftId, dipAmount);
+
+        // interactions
+        // collect DIP token from target owner
+        if (dipAmount.gtz()) {
+            $._stakingService.pullDipToken(dipAmount, transferFrom);
+        }
+    }
+
+
+    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 _updateRewards(
-        StakingReader reader,
-        StakingStore store,
+        StakingStorage storage $, 
         NftId stakeNftId
+    )
+        internal 
+        virtual 
+        returns (
+            Amount rewardIncreaseAmount,
+            Seconds targetLockingPeriod,
+            Amount stakeBalance,
+            Amount rewardBalance,
+            Timestamp lockedUntil
+        )
+    {
+        (
+            rewardIncreaseAmount,
+            targetLockingPeriod,
+            stakeBalance,
+            rewardBalance,
+            lockedUntil
+        ) = $._store.updateRewards(stakeNftId);
+
+        if (rewardIncreaseAmount.gtz()) {
+            emit LogStakingStakeRewardsUpdated(stakeNftId, rewardIncreaseAmount, stakeBalance, rewardBalance, lockedUntil);
+        }
+    }
+
+
+    function _unstakeAll(
+        StakingStorage storage $, 
+        NftId stakeNftId,
+        bool restakeRewards
     )
         internal
         virtual
-        returns (NftId targetNftId)
+        returns (
+            Amount unstakedAmount,
+            Amount claimedAmount,
+            Timestamp lockedUntil
+        )
     {
-        UFixed rewardRate;
+        // additional checks (most checks are done prior to calling this function)
+        if ($._store.isStakeLocked(stakeNftId)) {
+            revert ErrorStakingStakeLocked(stakeNftId, $._store.getStakeInfo(stakeNftId).lockedUntil);
+        }
+
+        // update rewards since last update
+        (,,,, lockedUntil) = _updateRewards($, stakeNftId);
+        Amount restakedRewardAmount;
+        Amount stakeBalance;
+        Amount rewardBalance;
 
-        (targetNftId, rewardRate) = reader.getTargetRewardRate(stakeNftId);
-        (Amount rewardIncrement, ) = StakeManagerLib.calculateRewardIncrease(
-            reader, 
+        (
+            restakedRewardAmount,
+            unstakedAmount,
+            claimedAmount,
+            stakeBalance,
+            rewardBalance,
+        ) = $._store.decreaseStakes(
             stakeNftId,
-            rewardRate);
+            AmountLib.max(), // unstake all stakes
+            AmountLib.max(), // claim all rewards
+            restakeRewards);
 
-        store.updateRewards(
-            stakeNftId, 
-            targetNftId,
-            rewardIncrement);
+        if (restakedRewardAmount.gtz()) {
+            emit LogStakingRewardsRestaked(stakeNftId, restakedRewardAmount, stakeBalance + unstakedAmount, rewardBalance + claimedAmount, lockedUntil);
+        }
+
+        if (unstakedAmount.gtz() || claimedAmount.gtz()) {
+            emit LogStakingUnstaked(stakeNftId, unstakedAmount + claimedAmount, stakeBalance, rewardBalance, lockedUntil);
+        }
+    }
+
+
+    function _addToken(
+        StakingStorage storage $,
+        ChainId chainId, 
+        address token
+    )
+        internal
+        virtual
+    {
+        if ($._store.getTokenInfo(chainId, token).lastUpdateIn.eqz()) {
+            $._store.addToken(chainId, token);
+
+            emit LogStakingTokenAdded(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 stakingStoreAddress,
-            address stakingOwner
-        ) = abi.decode(data, (address, address, address, address));
+            address stakingStoreAddress
+        ) = abi.decode(data, (address, address, address));
 
-        // only admin(authority) and dip token address are set in registry at this point
+        // wiring to external contracts
         IRegistry registry = IRegistry(registryAddress);
-        address authority = registry.getAuthority();
-        TokenRegistry tokenRegistry = TokenRegistry(tokenRegistryAddress);
-        address dipTokenAddress = tokenRegistry.getDipTokenAddress();
-
-        initializeComponent(
-            authority,
-            registryAddress, 
-            registry.getNftId(), 
+        StakingStorage storage $ = _getStakingStorage();
+        $._protocolNftId = registry.getProtocolNftId();
+        $._store = StakingStore(stakingStoreAddress);
+        $._reader = StakingStore(stakingStoreAddress).getStakingReader();
+        $._tokenRegistry = TokenRegistry(tokenRegistryAddress);
+        // staking service has to be set via setStakingService after deploying the first GIF release
+
+        __Component_init(
+            registry.getAuthority(),
+            address(registry), 
+            registry.getNftId(), // parent nft id
             CONTRACT_NAME,
-            dipTokenAddress,
             STAKING(), 
             false, // is interceptor
-            stakingOwner, 
+            owner, 
             "", // registry data
             ""); // component 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.
+        _checkAndLogProtocolTargetCreation();
 
-        // wiring to external contracts
+        _registerInterface(type(IStaking).interfaceId);
+    }
+
+
+    function _checkAndLogProtocolTargetCreation()
+        internal 
+        virtual
+    {
         StakingStorage storage $ = _getStakingStorage();
-        $._protocolNftId = getRegistry().getProtocolNftId();
-        $._store = StakingStore(stakingStoreAddress);
-        $._reader = StakingStore(stakingStoreAddress).getStakingReader();
-        $._tokenRegistry = TokenRegistry(tokenRegistryAddress);
+        TargetInfo memory protocolInfo = $._store.getTargetInfo($._protocolNftId);
 
-        registerInterface(type(IStaking).interfaceId);
+        if (protocolInfo.lastUpdateIn.eqz()) {
+            revert ErrorStakingTargetNotFound($._protocolNftId);
+        }
+
+        emit LogStakingTargetCreated($._protocolNftId, protocolInfo.objectType, protocolInfo.lockingPeriod, protocolInfo.rewardRate, protocolInfo.maxStakedAmount);
+    }
+
+
+    function _checkTypeAndOwner(NftId nftId, ObjectType expectedObjectType, bool checkOwner)
+        internal
+        view
+    {
+        if (expectedObjectType == STAKE()) {
+            if (!_getStakingStorage()._store.exists(nftId)) {
+                revert ErrorStakingNotStake(nftId);
+            }
+        } else {
+            if (expectedObjectType == TARGET()) {
+                if (!_getStakingStorage()._store.getTargetSet().exists(nftId)) {
+                    revert ErrorStakingNotTarget(nftId);
+                }
+            }
+        }
+
+        if (checkOwner) {
+            address nftOwner = getRegistry().ownerOf(nftId);
+            if (msg.sender != nftOwner) {
+                revert ErrorStakingNotOwner(nftId, nftOwner, msg.sender);
+            }
+        }
     }