@etherisc/gif-next 0.0.2-f1b01e0-214 → 0.0.2-f1e6957-384

package/contracts/staking/StakingStore.sol

@@ -2,140 +2,479 @@
 pragma solidity ^0.8.20;
 
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IStaking} from "./IStaking.sol";
+import {ITargetLimitHandler} from "./ITargetLimitHandler.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
+import {ChainId, ChainIdLib} from "../type/ChainId.sol";
 import {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
-import {KeyValueStore} from "../shared/KeyValueStore.sol";
-import {KEEP_STATE} from "../type/StateId.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {NftIdSet} from "../shared/NftIdSet.sol";
-import {PROTOCOL, STAKE, TARGET} from "../type/ObjectType.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {PROTOCOL, INSTANCE} from "../type/ObjectType.sol";
+import {Seconds, SecondsLib} from "../type/Seconds.sol";
+import {StakingLib} from "./StakingLib.sol";
 import {StakingReader} from "./StakingReader.sol";
 import {TargetManagerLib} from "./TargetManagerLib.sol";
 import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
-import {StakingLifecycle} from "./StakingLifecycle.sol";
-import {UFixed} from "../type/UFixed.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
 
 
 contract StakingStore is 
-    AccessManaged,
-    KeyValueStore,
-    StakingLifecycle
+    Initializable,
+    AccessManaged
 {
 
-    event LogStakingStoreReserveBalanceIncreased(NftId targetNftId, Amount dipAmount, Amount reserveBalance, Blocknumber lastUpdatedIn);
-    event LogStakingStoreReserveBalanceDecreased(NftId targetNftId, Amount dipAmount, Amount reserveBalance, Blocknumber lastUpdatedIn);
+    // token
+    error ErrorStakingStoreTokenNotRegistered(ChainId chainId, address token);
+    error ErrorStakingStoreTokenAlreadyAdded(ChainId chainId, address token);
+    error ErrorStakingStoreTokenUnknown(ChainId chainId, address token);
 
-    event LogStakingStoreTotalValueLockedIncreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdatedIn);
-    event LogStakingStoreTotalValueLockedDecreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdatedIn);
-
-    event LogStakingStoreStakesIncreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
-    event LogStakingStoreStakesDecreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
-
-    event LogStakingStoreRewardsIncreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
-    event LogStakingStoreRewardsDecreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
-
-    event LogStakingStoreRewardsRestaked(NftId nftId, Amount amount, Amount rewardAmount, Amount rewardIncrementAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    // target
+    error ErrorStakingStoreTargetNotInitialized(NftId targetNftId);
+    error ErrorStakingStoreLimitNotInitialized(NftId targetNftId);
 
     // in/decreasing reward reserves
     error ErrorStakingStoreNotTarget(NftId targetNftId);
-    error ErrorStakingStoreRewardReservesInsufficient(NftId targetNftId, Amount dipAmount, Amount reservesBalanceAmount);    
+    error ErrorStakingStoreRewardReservesInsufficient(NftId targetNftId, Amount reserveAmount, Amount claimedAmount);
 
-    // creating and updating of balance
-    error ErrorStakingStoreBalanceAlreadyInitialized(NftId nftId);
-    error ErrorStakingStoreBalanceNotInitialized(NftId nftId);
+    // stakes
+    error ErrorStakingStoreStakesExceedingTargetMaxAmount(NftId targetNftId, Amount stakeLimitAmount, Amount newIStaking);
+    error ErrorStakingStoreStakeNotInitialized(NftId nftId);
 
-    // update balance
-    error ErrorStakingStoreTvlBalanceNotInitialized(NftId nftId);
+    // creating and updating of staking balance
+    error ErrorStakingStoreStakeBalanceAlreadyInitialized(NftId nftId);
+    error ErrorStakingStoreStakeBalanceNotInitialized(NftId nftI);
+
+    // creating and updating of tvl balance
+    error ErrorStakingStoreTvlBalanceAlreadyInitialized(NftId nftId, address token);
+    error ErrorStakingStoreTvlBalanceNotInitialized(NftId nftId, address token);
 
     IRegistry private _registry;
-    NftIdSet private _targetNftIdSet;
+    ITargetLimitHandler private _targetLimitHandler;
     StakingReader private _reader;
+    NftIdSet private _targetNftIdSet;
 
-    // staking rate
-    mapping(uint256 chainId => mapping(address token => UFixed stakingRate)) private _stakingRate;
+    // target support
+    mapping(ObjectType targetType => IStaking.SupportInfo) private _supportInfo;
 
-    // total, stake and reward balances
-    mapping(NftId nftId => Amount stakes) private _stakeBalance;
-    mapping(NftId nftId => Amount rewards) private _rewardBalance;
-    mapping(NftId nftId => Amount reserves) private _reserveBalance;
+    // targets
+    mapping(NftId targetNftId => IStaking.TargetInfo) private _targetInfo;
+    mapping(NftId targetNftId => IStaking.LimitInfo) private _limitInfo;
+    mapping(NftId targetNftId => mapping(address token => IStaking.TvlInfo)) private _tvlInfo;
+    mapping(NftId targetNftId => address [] token) private _targetToken;
 
-    mapping(NftId nftId => Timestamp lastUpdatedAt) private _lastUpdatedAt;
-    mapping(NftId nftId => Blocknumber lastUpdatedIn) private _lastUpdatedIn;
+    // staking rate
+    mapping(ChainId chainId => mapping(address token => IStaking.TokenInfo)) private _tokenInfo;
 
-    // total value locked balance
-    mapping(NftId nftId => mapping(address token => Amount tvl)) private _tvlBalance;
-    mapping(NftId nftId => mapping(address token => Amount tvlInDip)) private _tvlInDip;
-    mapping(NftId nftId => Amount tvlRequiredDip) private _tvlRequiredDip;
-    mapping(NftId nftId => Blocknumber lastUpdatedIn) private _tvlLastUpdatedIn;
+    // stakes
+    mapping(NftId stakeNftId => IStaking.StakeInfo) private _stakeInfo;
 
 
-    constructor(IRegistry registry, StakingReader reader)
+    constructor(
+        IRegistry registry, 
+        StakingReader reader
+    )
         AccessManaged(msg.sender)
     {
         // set final authority
         setAuthority(registry.getAuthority());
 
         // set internal variables
-        _registry = registry; //TODO if keeps registry -> RegistryLinked and checks registry address
+        _registry = registry;
         _reader = reader;
         _targetNftIdSet = new NftIdSet();
 
+        _createInitialSetup();
         // register protocol target
+    }
+
+
+    function _createInitialSetup()
+        internal
+    {
+        // define support parameters for protocol target
+        _setSupportInfo(
+            PROTOCOL(), 
+            true, // isSupported
+            false, // allowNewTargets,
+            true, // crossChainIsSupported
+            AmountLib.zero(), // minStakingAmount
+            AmountLib.max(), // maxStakingAmount, 
+            SecondsLib.oneDay(), // minLockingPeriod, 
+            SecondsLib.oneYear(), // maxLockingPeriod, 
+            UFixedLib.zero(), // minRewardRate, 
+            UFixedLib.toUFixed(15, -2)); // maxRewardRate
+
+        // create protocol target
         _createTarget(
             NftIdLib.toNftId(1101), 
-            IStaking.TargetInfo({
-                objectType: PROTOCOL(),
-                chainId: 1,
-                lockingPeriod: TargetManagerLib.getDefaultLockingPeriod(),
-                rewardRate: TargetManagerLib.getDefaultRewardRate(),
-                maxStakedAmount: AmountLib.max()}));
+            PROTOCOL(),
+            TargetManagerLib.getDefaultLockingPeriod(),
+            TargetManagerLib.getDefaultRewardRate(),
+            false); // no parameter check
+
+        // define support parameters for instance targets
+        _setSupportInfo(
+            INSTANCE(), 
+            true, // isSupported
+            true, // allowNewTargets,
+            true, // allowCrossChain
+            AmountLib.toAmount(100000 * 10 ** 18), // minStakingAmount 100'000 DIP
+            AmountLib.max(), // maxStakingAmount, 
+            SecondsLib.oneDay(), // minLockingPeriod, 
+            SecondsLib.oneYear(), // maxLockingPeriod, 
+            UFixedLib.zero(), // minRewardRate, 
+            UFixedLib.toUFixed(3, -1)); // maxRewardRate 30%
+    }
+
+
+    function initialize(
+        address targetLimitHandler
+    )
+        external
+        initializer()
+    {
+        _targetLimitHandler = ITargetLimitHandler(targetLimitHandler);
+    }
+
+
+    //--- dependency management ---------------------------------------------//
+
+    function setStakingReader(address reader)
+        external
+        restricted()
+    {
+        address oldReader = address(_reader);
+        _reader = StakingReader(reader);
+
+        emit IStaking.LogStakingStakingReaderSet(reader, oldReader);
+    }
+
+
+    function setTargetLimitHandler(address targetLimitHandler )
+        external
+        restricted()
+    {
+        address oldTargetHandler = address(_targetLimitHandler);
+        _targetLimitHandler = ITargetLimitHandler(targetLimitHandler );
+
+        emit IStaking.LogStakingTargetHandlerSet(targetLimitHandler , oldTargetHandler);
+    }
+
+    //--- target support management -----------------------------------------//
+
+    /// @dev Generic setter for support info.
+    /// Any change in any of the parameters requires to set all parameters.
+    function setSupportInfo(
+        ObjectType targetType,
+        bool isSupported,
+        bool allowNewTargets,
+        bool allowCrossChain,
+        Amount minStakingAmount,
+        Amount maxStakingAmount,
+        Seconds minLockingPeriod,
+        Seconds maxLockingPeriod,
+        UFixed minRewardRate,
+        UFixed maxRewardRate
+    )
+        external
+        restricted()
+    {
+        _setSupportInfo(
+            targetType,
+            isSupported,
+            allowNewTargets,
+            allowCrossChain,
+            minStakingAmount,
+            maxStakingAmount,
+            minLockingPeriod,
+            maxLockingPeriod,
+            minRewardRate,
+            maxRewardRate);
+    }
+
+
+    function _setSupportInfo(
+        ObjectType targetType,
+        bool isSupported,
+        bool allowNewTargets,
+        bool allowCrossChain,
+        Amount minStakingAmount,
+        Amount maxStakingAmount,
+        Seconds minLockingPeriod,
+        Seconds maxLockingPeriod,
+        UFixed minRewardRate,
+        UFixed maxRewardRate
+    )
+        private
+    {
+        // checks
+        if (targetType.eqz()) {
+            revert IStaking.ErrorStakingSupportTypeInvalid(targetType);
+        }
+
+        // check staking amount limits
+        if (minStakingAmount > maxStakingAmount) {
+            revert IStaking.ErrorStakingStakingAmountsInvalid(minStakingAmount, maxStakingAmount);
+        }
+
+        // check locking period limits
+        if (minLockingPeriod > maxLockingPeriod) {
+            revert IStaking.ErrorStakingLockingPeriodsInvalid(minLockingPeriod, maxLockingPeriod);
+        }
+
+        // check reward rate limits
+        if (minRewardRate > maxRewardRate) {
+            revert IStaking.ErrorStakingRewardRatesInvalid(minRewardRate, maxRewardRate);
+        }
+
+        // effects
+        // remember previous last update
+        Blocknumber lastUpdateIn = _supportInfo[targetType].lastUpdateIn;
+
+        // set parameters to new values
+        _supportInfo[targetType].isSupported = isSupported;
+        _supportInfo[targetType].allowNewTargets = allowNewTargets;
+        _supportInfo[targetType].allowCrossChain = allowCrossChain;
+        _supportInfo[targetType].minStakingAmount = minStakingAmount;
+        _supportInfo[targetType].maxStakingAmount = maxStakingAmount;
+        _supportInfo[targetType].minLockingPeriod = minLockingPeriod;
+        _supportInfo[targetType].maxLockingPeriod = maxLockingPeriod;
+        _supportInfo[targetType].minRewardRate = minRewardRate;
+        _supportInfo[targetType].maxRewardRate = maxRewardRate;
+        // update last update
+        _supportInfo[targetType].lastUpdateIn = BlocknumberLib.current();
+
+        // logging
+        emit IStaking.LogStakingSupportInfoSet(
+            targetType,
+            isSupported,
+            allowNewTargets,
+            allowCrossChain,
+            minStakingAmount,
+            maxStakingAmount,
+            minLockingPeriod,
+            maxLockingPeriod,
+            minRewardRate,
+            maxRewardRate,
+            lastUpdateIn);
     }
 
+    /// @dev Returns the support info for the specified target type.
+    function getSupportInfo(ObjectType targetType)
+        external
+        view
+        returns (IStaking.SupportInfo memory supportInfo)
+    {
+        return _supportInfo[targetType];
+    }
+
+    //--- token management --------------------------------------------------//
+
+    /// @dev Registers a token for tvl management.
+    function addToken(
+        ChainId chainId, 
+        address token
+    )
+        external
+        restricted() // token registry via staking
+    {
+        // checks
+        IStaking.TokenInfo storage info = _tokenInfo[chainId][token];
+
+        // check token is not yet registered
+        if (info.lastUpdateIn.gtz()) {
+            revert ErrorStakingStoreTokenAlreadyAdded(chainId, token);
+        }
+
+        info.stakingRate = UFixedLib.zero();
+        info.lastUpdateIn = BlocknumberLib.current();
+
+        // logging
+        emit IStaking.LogStakingTokenAdded(chainId, token);
+    }
 
-    //--- staking rate specific functions -----------------------------------//
 
+    /// @dev Sets the staking rate for the token.
     function setStakingRate(
-        uint256 chainId, 
+        ChainId chainId, 
         address token, 
         UFixed stakingRate
     )
         external
-        restricted()
+        restricted() // staking
+        returns (
+            UFixed oldStakingRate,
+            Blocknumber lastUpdatedIn
+        )
     {
-        _stakingRate[chainId][token] = stakingRate;
+        IStaking.TokenInfo storage info = _tokenInfo[chainId][token];
+        if (info.lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreTokenUnknown(chainId, token);
+        }
+
+        // get previous values
+        oldStakingRate = info.stakingRate;
+        lastUpdatedIn = info.lastUpdateIn;
+
+        // update values
+        info.stakingRate = stakingRate;
+        info.lastUpdateIn = BlocknumberLib.current();
     }
 
-    //--- target specific functions -----------------------------------------//
+    //--- target management -------------------------------------------------//
 
     function createTarget(
         NftId targetNftId,
-        IStaking.TargetInfo memory targetInfo
+        ObjectType objectType,
+        Seconds lockingPeriod,
+        UFixed rewardRate
     )
         external
-        restricted()
+        restricted() // staking
     {
-        _createTarget(targetNftId, targetInfo);
+        _createTarget(targetNftId, objectType, lockingPeriod, rewardRate, true);
     }
 
 
-    function updateTarget(
+    function setLockingPeriod(
+        NftId targetNftId,
+        Seconds lockingPeriod
+    )
+        external
+        restricted() // staking
+    {
+        // checks
+        (
+            IStaking.TargetInfo storage targetInfo, 
+            Blocknumber lastUpdateIn
+        ) = _verifyAndUpdateTarget(targetNftId);
+
+        TargetManagerLib.checkLockingPeriod(_reader, targetNftId, targetInfo.objectType, lockingPeriod);
+
+        // effects
+        Seconds oldLockingPeriod = targetInfo.lockingPeriod;
+        targetInfo.lockingPeriod = lockingPeriod;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // logging
+        emit IStaking.LogStakingTargetLockingPeriodSet(targetNftId, lockingPeriod, oldLockingPeriod, lastUpdateIn);
+    }
+
+
+    function setRewardRate(
+        NftId targetNftId,
+        UFixed rewardRate
+    )
+        external
+        restricted() // staking
+    {
+        // checks
+        (
+            IStaking.TargetInfo storage targetInfo, 
+            Blocknumber lastUpdateIn
+        ) = _verifyAndUpdateTarget(targetNftId);
+
+        TargetManagerLib.checkRewardRate(_reader, targetNftId, targetInfo.objectType, rewardRate);
+
+        // effects
+        UFixed oldRewardRate = targetInfo.rewardRate;
+        targetInfo.rewardRate = rewardRate;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // logging
+        emit IStaking.LogStakingTargetRewardRateSet(targetNftId, rewardRate, oldRewardRate, lastUpdateIn);
+    }
+
+
+    // TODO refactor to set limits functionality
+    function setMaxStakedAmount(
+        NftId targetNftId,
+        Amount stakeLimitAmount
+    )
+        external
+        restricted() // staking
+        returns (
+            Amount oldLimitAmount,
+            Blocknumber lastUpdatedIn
+        )
+    {
+        IStaking.TargetInfo storage targetInfo;
+        (targetInfo, lastUpdatedIn) = _verifyAndUpdateTarget(targetNftId);
+
+        oldLimitAmount = targetInfo.limitAmount;
+        targetInfo.limitAmount = stakeLimitAmount;
+
+        emit IStaking.LogStakingTargetMaxStakedAmountSet(targetNftId, stakeLimitAmount, lastUpdatedIn);
+
+    }
+
+
+    function setTargetLimits(
         NftId targetNftId, 
-        IStaking.TargetInfo memory targetInfo
+        Amount marginAmount, 
+        Amount hardLimitAmount
+    )
+        external
+        virtual
+        restricted()
+    {
+        // checks
+        IStaking.LimitInfo storage limitInfo = _getAndVerifyLimit(targetNftId);
+        Blocknumber lastUpdateIn = limitInfo.lastUpdateIn;
+
+        // effects
+        limitInfo.marginAmount = marginAmount;
+        limitInfo.hardLimitAmount = hardLimitAmount;
+        limitInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // logging
+        emit IStaking.LogStakingTargetLimitsUpdated(
+            targetNftId,
+            marginAmount,
+            hardLimitAmount,
+            lastUpdateIn);
+    }
+
+
+    function addTargetToken(
+        NftId targetNftId,
+        address token
     )
         external
         restricted()
     {
-        _update(
-            targetNftId.toKey32(TARGET()), 
-            abi.encode(targetInfo), KEEP_STATE());
+        // checks
+
+        // skip registering if tvl balance has already been initialized
+        IStaking.TvlInfo storage tvlInfo = _tvlInfo[targetNftId][token];
+        if (tvlInfo.lastUpdateIn.gtz()) {
+            return;
+        }
+
+        // check target exists
+        _getAndVerifyTarget(targetNftId);
+
+        // check token is known for chain id of target
+        ChainId chainId = ChainIdLib.fromNftId(targetNftId);
+        if (_tokenInfo[chainId][token].lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreTokenUnknown(chainId, token);
+        }
+
+        // effects
+        tvlInfo.tvlAmount = AmountLib.zero();
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // add token to list of know tokens for target
+        _targetToken[targetNftId].push(token);
     }
 
 
-    function increaseReserves(
+    function refillRewardReserves(
         NftId targetNftId, 
         Amount dipAmount
     )
@@ -143,14 +482,26 @@ contract StakingStore is
         restricted()
         returns (Amount newReserveBalance)
     {
-        newReserveBalance = _reserveBalance[targetNftId] + dipAmount;
-        Blocknumber lastUpdatedIn = _updateReserves(targetNftId, newReserveBalance);
+        // checks
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(targetNftId);
+        Blocknumber lastUpdateIn = targetInfo.lastUpdateIn;
+
+        // effects
+        targetInfo.reserveAmount = targetInfo.reserveAmount + dipAmount;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
 
-        emit LogStakingStoreReserveBalanceIncreased(targetNftId, dipAmount, newReserveBalance, lastUpdatedIn);
+        // logging
+        newReserveBalance = targetInfo.reserveAmount;
+        emit IStaking.LogStakingRewardReservesRefilled(
+            targetNftId,
+            dipAmount,
+            _registry.ownerOf(targetNftId),
+            newReserveBalance,
+            lastUpdateIn);
     }
 
 
-    function decreaseReserves(
+    function withdrawRewardReserves(
         NftId targetNftId, 
         Amount dipAmount
     )
@@ -158,18 +509,20 @@ contract StakingStore is
         restricted()
         returns (Amount newReserveBalance)
     {
-        Amount reserveAmount = _reserveBalance[targetNftId];
-        if (dipAmount > reserveAmount) {
-            revert ErrorStakingStoreRewardReservesInsufficient(
-                targetNftId,
-                dipAmount,
-                reserveAmount);
-        }
+        // checks
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(targetNftId);
 
-        newReserveBalance = _reserveBalance[targetNftId] - dipAmount;
-        Blocknumber lastUpdatedIn = _updateReserves(targetNftId, newReserveBalance);
+        // effects
+        Blocknumber lastUpdateIn = _decreaseReserves(targetNftId, targetInfo, dipAmount);
 
-        emit LogStakingStoreReserveBalanceDecreased(targetNftId, dipAmount, newReserveBalance, lastUpdatedIn);
+        // logging
+        newReserveBalance = targetInfo.reserveAmount;
+        emit IStaking.LogStakingRewardReservesWithdrawn(
+            targetNftId,
+            dipAmount,
+            _registry.ownerOf(targetNftId),
+            newReserveBalance,
+            lastUpdateIn);
     }
 
 
@@ -177,7 +530,6 @@ contract StakingStore is
 
     function increaseTotalValueLocked(
         NftId targetNftId,
-        UFixed stakingRate,
         address token,
         Amount amount
     )
@@ -185,32 +537,24 @@ contract StakingStore is
         restricted()
         returns (Amount newBalance)
     {
-        (
-            Blocknumber tvlLastUpdatedIn,
-            Amount oldBalance,
-            Amount oldDipBalance
-        ) = _getAndVerifyTvl(targetNftId, token);
-
-        newBalance = oldBalance + amount;
-        Amount newDipBalance = newBalance.multiplyWith(stakingRate);
-
-        // update new tvl balances
-        _tvlBalance[targetNftId][token] = newBalance;
-        _tvlInDip[targetNftId][token] = newDipBalance;
-
-        // update new amount of required dip
-        _tvlRequiredDip[targetNftId] = _tvlRequiredDip[targetNftId] - oldDipBalance + newDipBalance;
-
-        // update last updated in
-        _tvlLastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
-
-        emit LogStakingStoreTotalValueLockedIncreased(targetNftId, token, amount, newBalance, tvlLastUpdatedIn);
+        // checks
+        IStaking.TvlInfo storage tvlInfo = _getAndVerifyTvl(targetNftId, token);
+        Blocknumber lastUpdateIn = tvlInfo.lastUpdateIn;
+
+        // effects
+        // update tvl balance and adapts required stakes if necessary
+        tvlInfo.tvlAmount = tvlInfo.tvlAmount + amount;
+        _checkAndUpdateTargetLimit(targetNftId, token, tvlInfo);
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
+        newBalance = tvlInfo.tvlAmount;
+
+        // logging
+        emit IStaking.LogStakingTvlIncreased(targetNftId, token, amount, newBalance, lastUpdateIn);
     }
 
 
     function decreaseTotalValueLocked(
         NftId targetNftId,
-        UFixed stakingRate,
         address token,
         Amount amount
     )
@@ -218,389 +562,807 @@ contract StakingStore is
         restricted()
         returns (Amount newBalance)
     {
-        (
-            Blocknumber tvlLastUpdatedIn,
-            Amount oldBalance,
-            Amount oldDipBalance
-        ) = _getAndVerifyTvl(targetNftId, token);
+        // checks
+        IStaking.TvlInfo storage tvlInfo = _getAndVerifyTvl(targetNftId, token);
+        Blocknumber lastUpdateIn = tvlInfo.lastUpdateIn;
+
+        // effects
+        // update tvl balance and adapts required stakes if necessary
+        tvlInfo.tvlAmount = tvlInfo.tvlAmount - amount;
+        _checkAndUpdateTargetLimit(targetNftId, token, tvlInfo);
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
+        newBalance = tvlInfo.tvlAmount;
+
+        // logging
+        emit IStaking.LogStakingTvlDecreased(targetNftId, token, amount, newBalance, lastUpdateIn);
+    }
 
-        newBalance = oldBalance - amount;
-        Amount newDipBalance = AmountLib.toAmount((
-            stakingRate * newBalance.toUFixed()).toInt());
 
-        // update new tvl balances
-        _tvlBalance[targetNftId][token] = newBalance;
-        _tvlInDip[targetNftId][token] = newDipBalance;
+    function updateTargetLimit(NftId targetNftId)
+        external
+        restricted()
+        returns (Amount stakeLimitAmount)
+    {
+        return _updateTargetLimit(targetNftId);
+    }
 
-        // update new amount of required dip
-        _tvlRequiredDip[targetNftId] = _tvlRequiredDip[targetNftId] - oldDipBalance + newDipBalance;
 
-        // update last updated in
-        _tvlLastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+    function _checkAndUpdateTargetLimit(
+        NftId targetNftId, 
+        address token,
+        IStaking.TvlInfo storage tvlInfo
+    )
+        internal
+    {
+        // update counter
+        tvlInfo.updatesCounter++;
+
+        // check if upgrade is necessary
+        bool updateRequired = _targetLimitHandler.isLimitUpdateRequired(
+            targetNftId, 
+            token, 
+            tvlInfo.updatesCounter,
+            tvlInfo.tvlBaselineAmount, 
+            tvlInfo.tvlAmount);
+
+        if (updateRequired) {
+            // reset baseline and counter
+            tvlInfo.tvlBaselineAmount = tvlInfo.tvlAmount;
+            tvlInfo.updatesCounter = 0;
+
+            // update limit
+            _updateTargetLimit(targetNftId);
+        }
+    }
+
 
-        emit LogStakingStoreTotalValueLockedDecreased(targetNftId, token, amount, newBalance, tvlLastUpdatedIn);
+    function _updateTargetLimit(NftId targetNftId)
+        internal
+        returns (Amount limitAmount)
+    {
+        // checks
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(targetNftId);
+        IStaking.LimitInfo storage limitInfo = _getAndVerifyLimit(targetNftId);
+        Blocknumber lastUpdateIn = limitInfo.lastUpdateIn;
+
+        // calculate max stake amount
+        Amount requiredStakeAmount = getRequiredStakeBalance(targetNftId, false);
+        // limitAmount = AmountLib.min(
+        //     targetInfo.limitAmount, 
+        //     requiredStakeAmount + limitInfo.marginAmount);
+        
+        // add margin to required stakes
+        limitAmount = requiredStakeAmount + limitInfo.marginAmount;
+        // cap at hard limit
+        limitAmount = AmountLib.min(limitAmount, limitInfo.hardLimitAmount);
+
+        // effects
+        targetInfo.limitAmount = limitAmount;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // logging
+        emit IStaking.LogStakingTargetLimitUpdated(
+            targetNftId,
+            targetInfo.limitAmount,
+            limitInfo.hardLimitAmount,
+            requiredStakeAmount,
+            targetInfo.stakedAmount,
+            lastUpdateIn);
     }
 
     //--- stake specific functions -------------------------------------//
 
-    function create(
+    function createStake(
         NftId stakeNftId, 
-        IStaking.StakeInfo memory stakeInfo
+        NftId targetNftId,
+        address stakeOwner,
+        Amount stakeAmount
     )
         external
         restricted()
+        returns (Timestamp lockedUntil)
     {
-        _create(
-            stakeNftId.toKey32(STAKE()),
-            abi.encode(stakeInfo));
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _stakeInfo[stakeNftId];
+        if (stakeInfo.lastUpdateIn.gtz()) {
+            revert ErrorStakingStoreStakeBalanceAlreadyInitialized(stakeNftId);
+        }
+
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(targetNftId);
+        _checkMaxStakedAmount(targetNftId, targetInfo, stakeAmount);
 
-        _createStakeBalance(stakeNftId);
+        // effects
+        stakeInfo.targetNftId = targetNftId;
+        stakeInfo.stakedAmount = AmountLib.zero();
+        stakeInfo.rewardAmount = AmountLib.zero();
+        stakeInfo.lockedUntil = TimestampLib.current();
+        _setStakeLastUpdatesToCurrent(stakeInfo);
+
+        // logging for creation of empty stake
+        emit IStaking.LogStakingStakeCreated(stakeNftId, stakeInfo.targetNftId, stakeInfo.stakedAmount, stakeInfo.lockedUntil, stakeOwner);
+
+        // process stake amount
+        _stake(stakeNftId, stakeInfo, targetInfo, targetInfo.lockingPeriod, stakeAmount);
+
+        return stakeInfo.lockedUntil;
     }
 
-    function update(
-        NftId stakeNftId, 
-        IStaking.StakeInfo memory stakeInfo
+
+    function stake(
+        NftId stakeNftId,
+        bool updateRewards,
+        bool restakeRewards,
+        Seconds additionalLockingPeriod,
+        Amount stakeAmount
     )
         external
         restricted()
     {
-        _update(
-            stakeNftId.toKey32(STAKE()),
-            abi.encode(stakeInfo),
-            KEEP_STATE());
-    }
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _getAndVerifyStake(stakeNftId);
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(stakeInfo.targetNftId);
 
-    //--- general functions --------------------------------------------//
+        if (updateRewards) {
+            _updateRewards(stakeNftId, stakeInfo, targetInfo);
+        }
 
+        if (restakeRewards) {
+            _restakeRewards(stakeNftId, stakeInfo, targetInfo);
+        }
 
-    function increaseStake(
-        NftId nftId, 
-        NftId targetNftId,
-        Amount amount
+        _stake(stakeNftId, stakeInfo, targetInfo, additionalLockingPeriod, stakeAmount);
+    }
+
+
+    function unstake(
+        NftId stakeNftId,
+        bool updateRewards,
+        bool restakeRewards,
+        Amount maxUnstakeAmount
     )
         external
         restricted()
+        returns (Amount unstakedAmount)
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _getAndVerifyStake(stakeNftId);
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(stakeInfo.targetNftId);
 
-        _updateStakeBalance(
-            nftId, 
-            _stakeBalance[nftId] + amount, // new stake balance
-            _rewardBalance[nftId]); // unchanged reward balance
+        if (updateRewards) {
+            _updateRewards(stakeNftId, stakeInfo, targetInfo);
+        }
 
-        _updateTargetBalance(
-            targetNftId,
-            _stakeBalance[targetNftId] + amount,
-            _rewardBalance[targetNftId]);
+        if (restakeRewards) {
+            _restakeRewards(stakeNftId, stakeInfo, targetInfo);
+        }
 
-        emit LogStakingStoreStakesIncreased(nftId, amount, _stakeBalance[nftId], lastUpdatedIn);
+        return _unstake(stakeNftId, stakeInfo, targetInfo, maxUnstakeAmount);
     }
 
 
-    function restakeRewards(
-        NftId nftId, 
-        NftId targetNftId,
-        Amount rewardIncrementAmount
-    )
+    function updateRewards(NftId stakeNftId)
         external
         restricted()
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
-        Amount stakeAmount = _stakeBalance[nftId];
-        Amount rewardAmount = _rewardBalance[nftId];
-
-        // move all rewards to stake balance
-        _updateStakeBalance(
-            nftId, 
-            stakeAmount + rewardAmount + rewardIncrementAmount, // new stake balance
-            AmountLib.zero()); // new reward balance
-
-        _updateTargetBalance(
-            targetNftId,
-            _stakeBalance[targetNftId] + rewardAmount + rewardIncrementAmount,
-            _rewardBalance[targetNftId] - rewardAmount);
-
-        emit LogStakingStoreRewardsRestaked(nftId, stakeAmount, rewardAmount, rewardIncrementAmount, _stakeBalance[nftId], lastUpdatedIn);
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _getAndVerifyStake(stakeNftId);
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(stakeInfo.targetNftId);
+        _updateRewards(stakeNftId, stakeInfo, targetInfo);
     }
 
 
-    function updateRewards(
-        NftId nftId, 
-        NftId targetNftId, 
-        Amount rewardIncrementAmount
+    function restakeRewards(
+        NftId stakeNftId,
+        bool updateRewards
     )
         external
         restricted()
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _getAndVerifyStake(stakeNftId);
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(stakeInfo.targetNftId);
 
-        // increse rewards by increment
-        _updateStakeBalance(
-            nftId, 
-            _stakeBalance[nftId], // unchanged stake balance
-            _rewardBalance[nftId] + rewardIncrementAmount); // new reward balance
-
-        _updateTargetBalance(
-            targetNftId,
-            _stakeBalance[targetNftId],
-            _rewardBalance[targetNftId] + rewardIncrementAmount);
+        if (updateRewards) {
+            _updateRewards(stakeNftId, stakeInfo, targetInfo);
+        }
 
-        emit LogStakingStoreRewardsIncreased(nftId, rewardIncrementAmount, _rewardBalance[nftId], lastUpdatedIn);
+        _restakeRewards(stakeNftId, stakeInfo, targetInfo);
     }
 
 
-    function claimUpTo(
-        NftId nftId, 
-        NftId targetNftId, 
+    function claimRewards(
+        NftId stakeNftId,
+        bool updateRewards,
         Amount maxClaimAmount
     )
         external
         restricted()
         returns (Amount claimedAmount)
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _getAndVerifyStake(stakeNftId);
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(stakeInfo.targetNftId);
 
-        // determine the claimable rewards amount
-        claimedAmount = AmountLib.min(maxClaimAmount, _rewardBalance[nftId]);
+        if (updateRewards) {
+            _updateRewards(stakeNftId, stakeInfo, targetInfo);
+        }
 
-        // decrease rewards by claimed amount
-        _updateStakeBalance(
-            nftId, 
-            _stakeBalance[nftId], // unchanged stake balance
-            _rewardBalance[nftId] - claimedAmount); // new reward balance
+        claimedAmount = _claimRewards(stakeNftId, stakeInfo, targetInfo, maxClaimAmount);
+    }
 
-        _updateTargetBalance(
-            targetNftId,
-            _stakeBalance[targetNftId],
-            _rewardBalance[targetNftId] - claimedAmount);
+    //--- view functions -----------------------------------------------//
 
-        emit LogStakingStoreRewardsDecreased(nftId, claimedAmount, _rewardBalance[nftId], lastUpdatedIn);
+    function getStakingReader() external view returns (StakingReader stakingReader){
+        return _reader;
     }
 
+    function getTargetManager() external view returns (ITargetLimitHandler targetLimitHandler ){
+        return _targetLimitHandler;
+    }
 
-    function unstakeUpTo(
-        NftId nftId, 
-        NftId targetNftId, 
-        Amount maxUnstakeAmount,
-        Amount maxClaimAmount
+
+    function exists(NftId stakeNftId) external view returns (bool) { 
+        return _stakeInfo[stakeNftId].lastUpdateIn.gtz();
+    }
+
+
+    function getRequiredStakeBalance(
+        NftId targetNftId,
+        bool includeTargetTypeRequirements
     )
-        external
-        restricted()
-        returns (
-            Amount unstakedAmount,
-            Amount claimedAmount
-        )
+        public
+        view
+        returns (Amount requiredStakeAmount)
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
+        address [] memory tokens = _targetToken[targetNftId];
+        if (tokens.length == 0) {
+            return AmountLib.zero();
+        }
 
-        // determine amounts
-        unstakedAmount = AmountLib.min(maxUnstakeAmount, _stakeBalance[nftId]);
-        claimedAmount = AmountLib.min(maxClaimAmount, _rewardBalance[nftId]);
+        // calculate tvl based required stake amount
+        requiredStakeAmount = AmountLib.zero();
+        ChainId targetChainId = _targetInfo[targetNftId].chainId;
+        address token;
+        Amount tvlAmount;
+        UFixed stakingRate;
 
-        // decrease stakes and rewards as determined
-        _updateStakeBalance(
-            nftId, 
-            _stakeBalance[nftId] - unstakedAmount, // unchanged stake balance
-            _rewardBalance[nftId] - claimedAmount); // new reward balance
+        for (uint256 i = 0; i < tokens.length; i++) {
+            token = tokens[i];
+            tvlAmount = _tvlInfo[targetNftId][token].tvlAmount;
+            if (tvlAmount.eqz()) { continue; }
 
-        _updateTargetBalance(
-            targetNftId,
-            _stakeBalance[targetNftId] - unstakedAmount,
-            _rewardBalance[targetNftId] - claimedAmount);
+            stakingRate = _tokenInfo[targetChainId][token].stakingRate;
+            if (stakingRate.eqz()) { continue; }
+
+            requiredStakeAmount = requiredStakeAmount + tvlAmount.multiplyWith(stakingRate);
+        }
+
+        // update required amount based on target type
+        if (includeTargetTypeRequirements) {
+            ObjectType targetType = _targetInfo[targetNftId].objectType;
+            IStaking.SupportInfo storage supportInfo = _supportInfo[targetType];
 
-        emit LogStakingStoreStakesDecreased(nftId, unstakedAmount, _stakeBalance[nftId], lastUpdatedIn);
-        emit LogStakingStoreRewardsDecreased(nftId, claimedAmount, _rewardBalance[nftId], lastUpdatedIn);
+            if (requiredStakeAmount < supportInfo.minStakingAmount) {
+                requiredStakeAmount = supportInfo.minStakingAmount;
+            } else if (requiredStakeAmount > supportInfo.maxStakingAmount) {
+                requiredStakeAmount = supportInfo.maxStakingAmount;
+            }
+        }
     }
 
-    //--- view functions -----------------------------------------------//
 
-    function getStakingReader() external view returns (StakingReader stakingReader){
-        return _reader;
+    /// @dev Returns true iff current stake amount is still locked
+    function isStakeLocked(NftId stakeNftId) public view returns (bool) { 
+        return _stakeInfo[stakeNftId].lockedUntil > TimestampLib.current(); 
     }
 
-    // TODO rename
-    function getTargetNftIdSet() external view returns (NftIdSet targetNftIdSet){
-        return _targetNftIdSet;
+
+    /// @dev Returns the stake infos for the specified stake.
+    function getStakeInfo(NftId stakeNftId) external view returns (IStaking.StakeInfo memory stakeInfo) { 
+        return _stakeInfo[stakeNftId]; 
     }
 
-    function getStakingRate(uint256 chainId, address token) external view returns (UFixed stakingRate) { return _stakingRate[chainId][token]; }
 
-    function exists(NftId stakeNftId) external view returns (bool) { return exists(stakeNftId.toKey32(STAKE())); }
+    /// @dev Returns the stake infos for the specified stake.
+    function getStakeTarget(NftId stakeNftId) external view returns (NftId targetNftId) { 
+        return _stakeInfo[stakeNftId].targetNftId; 
+    }
 
-    function getTotalValueLocked(NftId nftId, address token) external view returns (Amount tvlBalanceAmount) { return _tvlBalance[nftId][token]; }
-    function getRequiredStakeBalance(NftId nftId) external view returns (Amount requiredAmount) { return _tvlRequiredDip[nftId]; }
 
-    function getReserveBalance(NftId nftId) external view returns (Amount balanceAmount) { return _reserveBalance[nftId]; }
-    function getStakeBalance(NftId nftId) external view returns (Amount balanceAmount) { return _stakeBalance[nftId]; }
-    function getRewardBalance(NftId nftId) external view returns (Amount rewardAmount) { return _rewardBalance[nftId]; }
-    function getBalanceUpdatedAt(NftId nftId) external view returns (Timestamp updatedAt) { return _lastUpdatedAt[nftId]; }
-    function getBalanceUpdatedIn(NftId nftId) external view returns (Blocknumber blocknumber) { return _lastUpdatedIn[nftId]; }
+    /// @dev Returns the target infos for the specified target.
+    function getTargetInfo(NftId targetNftId) external view returns (IStaking.TargetInfo memory targetInfo) { 
+        return _targetInfo[targetNftId]; 
+    }
 
 
-    function getTargetBalances(NftId nftId)
-        external
-        view
-        returns (
-            Amount stakeBalance,
-            Amount rewardBalance,
-            Amount reserveBalance,
-            Blocknumber lastUpdatedIn
-        )
-    {
-        stakeBalance = _stakeBalance[nftId];
-        rewardBalance = _rewardBalance[nftId];
-        reserveBalance = _reserveBalance[nftId];
-        lastUpdatedIn = _lastUpdatedIn[nftId];
+    /// @dev Returns the target limit infos for the specified target.
+    function getLimitInfo(NftId targetNftId) external view returns (IStaking.LimitInfo memory limitInfo) { 
+        return _limitInfo[targetNftId]; 
     }
 
 
-    function getStakeBalances(NftId nftId)
-        external
-        view
+    /// @dev Returns the tvl infos for the specified target.
+    function getTvlInfo(NftId targetNftId, address token) external view returns (IStaking.TvlInfo memory tvlInfo) {
+        return _tvlInfo[targetNftId][token];
+    }
+
+
+    /// @dev Returns the tvl infos for the specified target.
+    function getTokenInfo(ChainId chainId, address token) external view returns (IStaking.TokenInfo memory tokenInfo) {
+        return _tokenInfo[chainId][token];
+    }
+
+    function hasTokenInfo(ChainId chainId, address token) external view returns (bool) {
+        return _tokenInfo[chainId][token].lastUpdateIn.gtz();
+    }
+
+
+    function getTargetSet() external view returns (NftIdSet targetNftIdSet) { 
+        return _targetNftIdSet;
+    }
+
+    //--- internal functions -----------------------------------------------//
+
+    function _verifyAndUpdateTarget(NftId targetNftId)
+        private
         returns (
-            Amount stakeBalance,
-            Amount rewardBalance,
-            Timestamp lastUpdatedAt
+            IStaking.TargetInfo storage targetInfo,
+            Blocknumber lastUpdatedIn
         )
     {
-        stakeBalance = _stakeBalance[nftId];
-        rewardBalance = _rewardBalance[nftId];
-        lastUpdatedAt = _lastUpdatedAt[nftId];
+        // checks
+        targetInfo = _getAndVerifyTarget(targetNftId);
+        lastUpdatedIn = targetInfo.lastUpdateIn;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
     }
 
-    //--- private functions -------------------------------------------//
 
     function _createTarget(
         NftId targetNftId,
-        IStaking.TargetInfo memory targetInfo
+        ObjectType objectType,
+        Seconds lockingPeriod,
+        UFixed rewardRate,
+        bool checkParameters
     )
         private
     {
-        _create(
-            targetNftId.toKey32(TARGET()),
-            abi.encode(targetInfo));
-
-        // initialize tvl and stake balance
-        _tvlLastUpdatedIn[targetNftId]= BlocknumberLib.currentBlocknumber();
-        _createTargetBalance(targetNftId);
+        // checks
+        if (checkParameters) {
+            TargetManagerLib.checkTargetParameters(
+                _registry, 
+                _reader, 
+                targetNftId, 
+                objectType, 
+                lockingPeriod, 
+                rewardRate);
+        }
 
+        // effects
+
+        // target info
+        IStaking.TargetInfo storage targetInfo = _targetInfo[targetNftId];
+        targetInfo.stakedAmount = AmountLib.zero();
+        targetInfo.rewardAmount = AmountLib.zero();
+        targetInfo.reserveAmount = AmountLib.zero();
+        targetInfo.limitAmount = AmountLib.max();
+
+        targetInfo.objectType = objectType;
+        targetInfo.lockingPeriod = lockingPeriod;
+        targetInfo.rewardRate = rewardRate;
+        targetInfo.chainId = ChainIdLib.fromNftId(targetNftId);
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // create limit info
+        _setLimits(
+            _limitInfo[targetNftId],
+            targetNftId, 
+            AmountLib.toAmount(AmountLib.max().toInt() / 2), // margin limit
+            AmountLib.max()); // hard limit
+
+        // add new target to target set
         _targetNftIdSet.add(targetNftId);
+
+        // logging
+        emit IStaking.LogStakingTargetCreated(targetNftId, objectType, lockingPeriod, rewardRate);
     }
 
-    function _updateReserves(
-        NftId targetNftId, 
-        Amount newRewardBalance
+
+    function _setLimits(
+        IStaking.LimitInfo storage limitInfo,
+        NftId targetNftId,
+        Amount marginAmount,
+        Amount hardLimitAmount
     )
         private
-        returns (Blocknumber lastUpdatedIn)
     {
-        if (_lastUpdatedIn[targetNftId].eqz()) {
-            revert ErrorStakingStoreNotTarget(targetNftId);
-        }
+        // effects
+        Blocknumber lastUpdateIn = limitInfo.lastUpdateIn;
+        limitInfo.marginAmount = marginAmount;
+        limitInfo.hardLimitAmount = hardLimitAmount;
+        limitInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // logging
+        emit IStaking.LogStakingLimitsSet(targetNftId, limitInfo.marginAmount , limitInfo.hardLimitAmount, lastUpdateIn);
+    }
+
 
-        lastUpdatedIn = _lastUpdatedIn[targetNftId];
+    function _spendRewardReserves(
+        NftId targetNftId, 
+        IStaking.TargetInfo storage targetInfo,
+        Amount dipAmount
+    )
+        private
+    {
+        Blocknumber lastUpdateIn = _decreaseReserves(targetNftId, targetInfo, dipAmount);
 
-        _reserveBalance[targetNftId] = newRewardBalance;
-        _lastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+        // logging
+        emit IStaking.LogStakingRewardReservesSpent(
+            targetNftId,
+            dipAmount,
+            targetInfo.reserveAmount,
+            lastUpdateIn);
     }
 
 
-    function _createTargetBalance(NftId nftId)
+    function _decreaseReserves(
+        NftId targetNftId,
+        IStaking.TargetInfo storage targetInfo, 
+        Amount dipAmount
+    )
         private
+        returns ( Blocknumber lastUpdateIn)
     {
-        if (_lastUpdatedIn[nftId].gtz()) {
-            revert ErrorStakingStoreBalanceAlreadyInitialized(nftId);
+        lastUpdateIn = targetInfo.lastUpdateIn;
+
+        // check if reserves are sufficient
+        if (dipAmount > targetInfo.reserveAmount) {
+            revert ErrorStakingStoreRewardReservesInsufficient(
+                targetNftId,
+                targetInfo.reserveAmount,
+                dipAmount);
         }
 
-        // set target balances to 0
-        _stakeBalance[nftId] = AmountLib.zero();
-        _rewardBalance[nftId] = AmountLib.zero();
-        _reserveBalance[nftId] = AmountLib.zero();
+        // effects
+        targetInfo.reserveAmount = targetInfo.reserveAmount - dipAmount;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+    }
 
-        // set last updated in to current block number
-        // we don't need last updated at timestamp for targets
-        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+
+    function _updateRewards(
+        NftId stakeNftId,
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo
+    )
+        internal
+        returns (Amount rewardIncreaseAmount)
+    {
+        // return if reward rate is zero
+        if (targetInfo.rewardRate.eqz()) {
+            return rewardIncreaseAmount;
+        }
+
+        // get seconds since last update on stake
+        Seconds duration = SecondsLib.toSeconds(
+            block.timestamp - stakeInfo.lastUpdateAt.toInt());
+
+        // return if duration is zero
+        if (duration.eqz()) {
+            return AmountLib.zero();
+        }
+        
+        // calculate reward increase since
+        rewardIncreaseAmount = StakingLib.calculateRewardAmount(
+            targetInfo.rewardRate,
+            duration,
+            stakeInfo.stakedAmount);
+
+        // update target + stake
+        targetInfo.rewardAmount = targetInfo.rewardAmount + rewardIncreaseAmount;
+        stakeInfo.rewardAmount = stakeInfo.rewardAmount + rewardIncreaseAmount;
+        Blocknumber lastUpdateIn = _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingStakeRewardsUpdated(
+            stakeNftId, 
+            rewardIncreaseAmount, 
+            stakeInfo.stakedAmount, 
+            stakeInfo.rewardAmount, 
+            stakeInfo.lockedUntil,
+            lastUpdateIn);
     }
 
 
-    function _createStakeBalance(NftId nftId)
-        private
+    function _restakeRewards(
+        NftId stakeNftId,
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo
+    )
+        internal
+        returns (Amount restakeAmount)
     {
-        if (_lastUpdatedIn[nftId].gtz()) {
-            revert ErrorStakingStoreBalanceAlreadyInitialized(nftId);
+        restakeAmount = stakeInfo.rewardAmount;
+
+        // return if reward amount is zero
+        if (restakeAmount.eqz()) {
+            return restakeAmount;
         }
 
-        // set stake balances to 0
-        _stakeBalance[nftId] = AmountLib.zero();
-        _rewardBalance[nftId] = AmountLib.zero();
+        // check restaking amount does not exceed target max staked amount
+        _checkMaxStakedAmount(stakeInfo.targetNftId, targetInfo, restakeAmount);
+
+        // use up reserves for newly staked dips
+        _spendRewardReserves(stakeInfo.targetNftId, targetInfo, restakeAmount);
+
+        // update target + stake
+        targetInfo.stakedAmount = targetInfo.stakedAmount + restakeAmount;
+        targetInfo.rewardAmount = targetInfo.rewardAmount - restakeAmount;
+        stakeInfo.stakedAmount = stakeInfo.stakedAmount + restakeAmount;
+        stakeInfo.rewardAmount = AmountLib.zero();
+        Blocknumber lastUpdateIn = _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingRewardsRestaked(
+            stakeNftId,
+            restakeAmount, 
+            stakeInfo.stakedAmount, 
+            AmountLib.zero(), 
+            stakeInfo.lockedUntil,
+            lastUpdateIn);
+    }
+
 
-        // set last updated at/in to current timestamp/block number
-        _lastUpdatedAt[nftId] = TimestampLib.blockTimestamp();
-        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+    function _stake(
+        NftId stakeNftId,
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo,
+        Seconds maxAdditionalLockingPeriod,
+        Amount stakeAmount
+    )
+        internal
+    {
+        // return if reward amount is zero
+        if (stakeAmount.eqz()) {
+            return;
+        }
+
+        // check restaking amount does not exceed target max staked amount
+        _checkMaxStakedAmount(stakeInfo.targetNftId, targetInfo, stakeAmount);
+
+        // update target + stake
+        targetInfo.stakedAmount = targetInfo.stakedAmount + stakeAmount;
+        stakeInfo.stakedAmount = stakeInfo.stakedAmount + stakeAmount;
+
+        // increase locked until if applicable
+        Seconds additionalLockingPeriod = SecondsLib.min(maxAdditionalLockingPeriod, targetInfo.lockingPeriod);
+        if (stakeAmount.gtz() && additionalLockingPeriod.gtz()) {
+            stakeInfo.lockedUntil = stakeInfo.lockedUntil.addSeconds(additionalLockingPeriod);
+        }
+
+        Blocknumber lastUpdateIn = _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingStaked(
+            stakeNftId,
+            stakeAmount, 
+            stakeInfo.stakedAmount, 
+            stakeInfo.rewardAmount, 
+            stakeInfo.lockedUntil,
+            lastUpdateIn);
     }
 
 
-    function _updateStakeBalance(
+    function _claimRewards(
         NftId stakeNftId,
-        Amount newStakeAmount,
-        Amount newRewardAmount
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo,
+        Amount maxClaimAmount
     )
-        private
+        internal
+        returns (Amount claimAmount)
+    {
+        claimAmount = AmountLib.min(maxClaimAmount, stakeInfo.rewardAmount);
+
+        // return if no rewards to claim
+        if (claimAmount.eqz()) {
+            return claimAmount;
+        }
+
+        // effects
+        // use up reserves for claimed rewards
+        _spendRewardReserves(stakeInfo.targetNftId, targetInfo, claimAmount);
+
+        // update target + stake
+        targetInfo.rewardAmount = targetInfo.rewardAmount - claimAmount;
+        stakeInfo.rewardAmount = stakeInfo.rewardAmount - claimAmount;
+        Blocknumber lastUpdateIn = _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingRewardsClaimed(
+            stakeNftId,
+            claimAmount, 
+            stakeInfo.stakedAmount, 
+            stakeInfo.rewardAmount, 
+            stakeInfo.lockedUntil,
+            lastUpdateIn);
+    }
+
+
+    function _unstake(
+        NftId stakeNftId,
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo,
+        Amount maxUnstakeAmount
+    )
+        internal
+        returns (Amount unstakedAmount)
     {
-        _stakeBalance[stakeNftId] = newStakeAmount;
-        _rewardBalance[stakeNftId] = newRewardAmount;
+        unstakedAmount = AmountLib.min(maxUnstakeAmount, stakeInfo.stakedAmount);
+
+        // return if no stakes to claim
+        if (unstakedAmount.eqz()) {
+            return unstakedAmount;
+        }
 
-        _lastUpdatedAt[stakeNftId] = TimestampLib.blockTimestamp();
-        _lastUpdatedIn[stakeNftId] = BlocknumberLib.currentBlocknumber();
+        // check if stake is still locked
+        if (isStakeLocked(stakeNftId)) {
+            revert IStaking.ErrorStakingStakeLocked(stakeNftId, stakeInfo.lockedUntil);
+        }
+
+        // update target + stake
+        targetInfo.stakedAmount = targetInfo.stakedAmount - unstakedAmount;
+        stakeInfo.stakedAmount = stakeInfo.stakedAmount - unstakedAmount;
+        Blocknumber lastUpdateIn = _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingUnstaked(
+            stakeNftId,
+            unstakedAmount, 
+            stakeInfo.stakedAmount, 
+            stakeInfo.rewardAmount, 
+            stakeInfo.lockedUntil,
+            lastUpdateIn);
     }
 
 
-    function _updateTargetBalance(
-        NftId targetNftId,
-        Amount newStakeAmount,
-        Amount newRewardAmount
+    function _setLastUpdatesToCurrent(
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo
+    )
+        internal
+        returns (Blocknumber lastUpdateIn)
+    {
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+        lastUpdateIn = _setStakeLastUpdatesToCurrent(stakeInfo);
+    }
+
+
+    function _setStakeLastUpdatesToCurrent(
+        IStaking.StakeInfo storage stakeInfo
+    )
+        internal
+        returns (Blocknumber lastUpdateIn)
+    {
+        lastUpdateIn = stakeInfo.lastUpdateIn;
+        stakeInfo.lastUpdateIn = BlocknumberLib.current();
+        stakeInfo.lastUpdateAt = TimestampLib.current();
+    }
+
+    //--- private stake and target functions --------------------------------//
+
+
+    function _getAndVerifyStake(
+        NftId stakeNftId
     )
         private
+        view
+        returns (
+            IStaking.StakeInfo storage stakeInfo
+        )
     {
-        _stakeBalance[targetNftId] = newStakeAmount;
-        _rewardBalance[targetNftId] = newRewardAmount;
+        stakeInfo = _stakeInfo[stakeNftId];
+        if (stakeInfo.lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreStakeNotInitialized(stakeNftId);
+        }
+    }
+
 
-        // for targets we don't need the timestamp, just the blocknumber
-        _lastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+    function _checkMaxStakedAmount(
+        NftId targetNftId, 
+        IStaking.TargetInfo storage targetInfo, 
+        Amount additionalstakedAmount
+    )
+        private
+    {
+        if (targetInfo.stakedAmount + additionalstakedAmount > targetInfo.limitAmount) {
+            revert IStaking.ErrorStakingTargetMaxStakedAmountExceeded(
+                targetNftId,
+                targetInfo.limitAmount,
+                targetInfo.stakedAmount + additionalstakedAmount);
+        }
+
+        // TODO add check for tvl dependent maximum, see #628
     }
 
-    function _checkBalanceExists(NftId nftId)
+
+    function _getAndVerifyTarget(
+        NftId targetNftId
+    )
         private
         view
-        returns (Blocknumber lastUpdatedIn)
+        returns (
+            IStaking.TargetInfo storage targetInfo
+        )
     {
-        lastUpdatedIn = _lastUpdatedIn[nftId];
+        targetInfo = _targetInfo[targetNftId];
 
-        if (lastUpdatedIn.eqz()) {
-            revert ErrorStakingStoreBalanceNotInitialized(nftId);
+        if (targetInfo.lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreTargetNotInitialized(targetNftId);
         }
     }
 
 
-    function _getAndVerifyTvl(
-        NftId targetNftId,
-        address token
+    function _getAndVerifyLimit(
+        NftId targetNftId
     )
         private
         view
         returns (
-            Blocknumber tvlLastUpdatedIn,
-            Amount oldBalance,
-            Amount oldDipBalance
+            IStaking.LimitInfo storage limitInfo
         )
     {
-        tvlLastUpdatedIn = _tvlLastUpdatedIn[targetNftId];
+        limitInfo = _limitInfo[targetNftId];
 
-        if (tvlLastUpdatedIn.eqz()) {
-            revert ErrorStakingStoreTvlBalanceNotInitialized(targetNftId);
+        if (limitInfo.lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreLimitNotInitialized(targetNftId);
         }
+    }
+
+    //--- private tvl functions ------------------------------------------------//
 
-        oldBalance = _tvlBalance[targetNftId][token];
-        oldDipBalance = _tvlInDip[targetNftId][token];
+    /// @dev Initializes token balance handling for the specified target.
+    function _createTvlBalance(NftId targetNftId, address token)
+        private
+    {
+        IStaking.TvlInfo storage info = _tvlInfo[targetNftId][token];
+
+        if (info.lastUpdateIn.gtz()) {
+            revert ErrorStakingStoreTvlBalanceAlreadyInitialized(targetNftId, token);
+        }
+
+        // set tvl balances to 0 and update last updated in
+        info.tvlAmount = AmountLib.zero();
+        info.lastUpdateIn = BlocknumberLib.current();
+    }
+
+
+    function _updateTvlBalance(
+        NftId targetNftId,
+        address token,
+        Amount newTvlAmount
+    )
+        private
+        returns (
+            Amount oldTvlAmount,
+            Blocknumber lastUpdatedIn
+        )
+    {
+        IStaking.TvlInfo storage tvlInfo = _getAndVerifyTvl(targetNftId, token);
+        oldTvlAmount = tvlInfo.tvlAmount;
+        lastUpdatedIn = tvlInfo.lastUpdateIn;
+
+        tvlInfo.tvlAmount = newTvlAmount;
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
+    }
+
+
+    function _getAndVerifyTvl(NftId targetNftId, address token)
+        private
+        view
+        returns (IStaking.TvlInfo storage tvlInfo)
+    {
+        tvlInfo = _tvlInfo[targetNftId][token];
+        if (tvlInfo.lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreTvlBalanceNotInitialized(targetNftId, token);
+        }
     }
 }