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

package/contracts/staking/StakingStore.sol

@@ -3,31 +3,26 @@ pragma solidity ^0.8.20;
 
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 
-import {Amount, AmountLib} from "../type/Amount.sol";
-import {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
-import {ChainNft} from "../registry/ChainNft.sol";
-import {Component} from "../shared/Component.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
-import {IRegistryService} from "../registry/IRegistryService.sol";
 import {IStaking} from "./IStaking.sol";
-import {IVersionable} from "../shared/IVersionable.sol";
-import {Key32} from "../type/Key32.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 {ObjectType, INSTANCE, PROTOCOL, STAKE, STAKING, TARGET} from "../type/ObjectType.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {PROTOCOL, STAKE, TARGET} from "../type/ObjectType.sol";
 import {Seconds, SecondsLib} from "../type/Seconds.sol";
+import {StakingLib} from "./StakingLib.sol";
+import {StakingLifecycle} from "./StakingLifecycle.sol";
 import {StakingReader} from "./StakingReader.sol";
 import {TargetManagerLib} from "./TargetManagerLib.sol";
 import {Timestamp, TimestampLib} from "../type/Timestamp.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 {RegistryAdmin} from "../registry/RegistryAdmin.sol";
-import {StakingLifecycle} from "./StakingLifecycle.sol";
 
 
 contract StakingStore is 
@@ -36,51 +31,44 @@ contract StakingStore is
     StakingLifecycle
 {
 
-    event LogStakingStoreReserveBalanceIncreased(NftId targetNftId, Amount dipAmount, Amount reserveBalance, Blocknumber lastUpdatedIn);
-    event LogStakingStoreReserveBalanceDecreased(NftId targetNftId, Amount dipAmount, Amount reserveBalance, Blocknumber lastUpdatedIn);
-
-    event LogStakingStoreTotalValueLockedIncreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdatedIn);
-    event LogStakingStoreTotalValueLockedDecreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdatedIn);
+    // token
+    error ErrorStakingStoreTokenNotRegistered(ChainId chainId, address token);
+    error ErrorStakingStoreTokenAlreadyAdded(ChainId chainId, address token);
+    error ErrorStakingStoreTokenUnknown(ChainId chainId, address token);
 
-    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);
 
     // 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 maxStakedAmount, 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;
     StakingReader private _reader;
 
-    // staking rate
-    mapping(uint256 chainId => mapping(address token => UFixed stakingRate)) private _stakingRate;
-
-    // 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;
+    // stakes
+    mapping(NftId stakeNftId => IStaking.StakeInfo) private _stakeInfo;
 
-    mapping(NftId nftId => Timestamp lastUpdatedAt) private _lastUpdatedAt;
-    mapping(NftId nftId => Blocknumber lastUpdatedIn) private _lastUpdatedIn;
+    // targets
+    mapping(NftId targetNftId => IStaking.TargetInfo) private _targetInfo;
+    mapping(NftId targetNftId => mapping(address token => IStaking.TvlInfo)) private _tvlInfo;
+    mapping(NftId targetNftId => address [] token) _targetToken;
 
-    // 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;
+    // staking rate
+    mapping(ChainId chainId => mapping(address token => IStaking.TokenInfo)) private _tokenInfo;
 
 
     constructor(IRegistry registry, StakingReader reader)
@@ -90,526 +78,817 @@ contract StakingStore is
         setAuthority(registry.getAuthority());
 
         // set internal variables
-        _registry = registry; //TODO if keeps registry -> RegistryLinked and checks registry address
+        _registry = registry;
         _reader = reader;
         _targetNftIdSet = new NftIdSet();
 
         // register protocol target
         _createTarget(
             NftIdLib.toNftId(1101), 
-            IStaking.TargetInfo({
-                objectType: PROTOCOL(),
-                chainId: 1,
-                lockingPeriod: TargetManagerLib.getDefaultLockingPeriod(),
-                rewardRate: TargetManagerLib.getDefaultRewardRate()}));
+            PROTOCOL(),
+            TargetManagerLib.getDefaultLockingPeriod(),
+            TargetManagerLib.getDefaultRewardRate(),
+            false); // no parameter check
     }
 
 
-    //--- staking rate specific functions -----------------------------------//
+    //--- 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();
+    }
+
 
+    /// @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(
-        NftId targetNftId, 
-        IStaking.TargetInfo memory targetInfo
+    function setLockingPeriod(
+        NftId targetNftId,
+        Seconds lockingPeriod
     )
         external
-        restricted()
+        restricted() // staking
+        returns (
+            Seconds oldLockingPeriod,
+            Blocknumber lastUpdatedIn
+        )
     {
-        _update(
-            targetNftId.toKey32(TARGET()), 
-            abi.encode(targetInfo), KEEP_STATE());
+        TargetManagerLib.checkLockingPeriod(targetNftId, lockingPeriod);
+
+        IStaking.TargetInfo storage targetInfo;
+        (targetInfo, lastUpdatedIn) = _verifyAndUpdateTarget(targetNftId);
+
+        oldLockingPeriod = targetInfo.lockingPeriod;
+        targetInfo.lockingPeriod = lockingPeriod;
     }
 
 
-    function increaseReserves(
-        NftId targetNftId, 
-        Amount dipAmount
+    function setRewardRate(
+        NftId targetNftId,
+        UFixed rewardRate
     )
         external
-        restricted()
-        returns (Amount newReserveBalance)
+        restricted() // staking
+        returns (
+            UFixed oldRewardRate,
+            Blocknumber lastUpdatedIn
+        )
     {
-        newReserveBalance = _reserveBalance[targetNftId] + dipAmount;
-        Blocknumber lastUpdatedIn = _updateReserves(targetNftId, newReserveBalance);
+        TargetManagerLib.checkRewardRate(targetNftId, rewardRate);
+
+        IStaking.TargetInfo storage targetInfo;
+        (targetInfo, lastUpdatedIn) = _verifyAndUpdateTarget(targetNftId);
 
-        emit LogStakingStoreReserveBalanceIncreased(targetNftId, dipAmount, newReserveBalance, lastUpdatedIn);
+        oldRewardRate = targetInfo.rewardRate;
+        targetInfo.rewardRate = rewardRate;
     }
 
 
-    function decreaseReserves(
-        NftId targetNftId, 
-        Amount dipAmount
+    function setMaxStakedAmount(
+        NftId targetNftId,
+        Amount maxStakedAmount
     )
         external
-        restricted()
-        returns (Amount newReserveBalance)
+        restricted() // staking
+        returns (
+            Amount oldMaxStakedAmount,
+            Blocknumber lastUpdatedIn
+        )
     {
-        Amount reserveAmount = _reserveBalance[targetNftId];
-        if (dipAmount > reserveAmount) {
-            revert ErrorStakingStoreRewardReservesInsufficient(
-                targetNftId,
-                dipAmount,
-                reserveAmount);
-        }
-
-        newReserveBalance = _reserveBalance[targetNftId] - dipAmount;
-        Blocknumber lastUpdatedIn = _updateReserves(targetNftId, newReserveBalance);
+        IStaking.TargetInfo storage targetInfo;
+        (targetInfo, lastUpdatedIn) = _verifyAndUpdateTarget(targetNftId);
 
-        emit LogStakingStoreReserveBalanceDecreased(targetNftId, dipAmount, newReserveBalance, lastUpdatedIn);
+        oldMaxStakedAmount = targetInfo.maxStakedAmount;
+        targetInfo.maxStakedAmount = maxStakedAmount;
     }
 
 
-    //--- tvl specific functions -------------------------------------//
+    // TODO move to private functions
+    function _verifyAndUpdateTarget(NftId targetNftId)
+        private
+        returns (
+            IStaking.TargetInfo storage targetInfo,
+            Blocknumber lastUpdatedIn
+        )
+    {
+        // checks
+        targetInfo = _getAndVerifyTarget(targetNftId);
+        lastUpdatedIn = targetInfo.lastUpdateIn;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+    }
 
-    function increaseTotalValueLocked(
+
+    // TODO move to private functions
+    function _createTarget(
         NftId targetNftId,
-        UFixed stakingRate,
-        address token,
-        Amount amount
+        ObjectType objectType,
+        Seconds lockingPeriod,
+        UFixed rewardRate,
+        bool checkParameters
     )
-        external
-        restricted()
-        returns (Amount newBalance)
+        private
     {
-        (
-            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;
+        // checks
+        if (checkParameters) {
+            TargetManagerLib.checkTargetParameters(
+                _registry, 
+                _reader, 
+                targetNftId, 
+                objectType, 
+                lockingPeriod, 
+                rewardRate);
+        }
 
-        // update new amount of required dip
-        _tvlRequiredDip[targetNftId] = _tvlRequiredDip[targetNftId] - oldDipBalance + newDipBalance;
+        // effects
+        IStaking.TargetInfo storage targetInfo = _targetInfo[targetNftId];
+        targetInfo.stakedAmount = AmountLib.zero();
+        targetInfo.rewardAmount = AmountLib.zero();
+        targetInfo.reserveAmount = AmountLib.zero();
+        targetInfo.maxStakedAmount = AmountLib.max();
 
-        // update last updated in
-        _tvlLastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+        targetInfo.objectType = objectType;
+        targetInfo.lockingPeriod = lockingPeriod;
+        targetInfo.rewardRate = rewardRate;
+        targetInfo.chainId = ChainIdLib.fromNftId(targetNftId);
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
 
-        emit LogStakingStoreTotalValueLockedIncreased(targetNftId, token, amount, newBalance, tvlLastUpdatedIn);
+        // add new target to target set
+        _targetNftIdSet.add(targetNftId);
     }
 
 
-    function decreaseTotalValueLocked(
+    function addTargetToken(
         NftId targetNftId,
-        UFixed stakingRate,
-        address token,
-        Amount amount
+        address token
     )
         external
         restricted()
-        returns (Amount newBalance)
     {
-        (
-            Blocknumber tvlLastUpdatedIn,
-            Amount oldBalance,
-            Amount oldDipBalance
-        ) = _getAndVerifyTvl(targetNftId, token);
+        // checks
 
-        newBalance = oldBalance - amount;
-        Amount newDipBalance = AmountLib.toAmount((
-            stakingRate * newBalance.toUFixed()).toInt());
+        // skip registering if tvl balance has already been initialized
+        IStaking.TvlInfo storage tvlInfo = _tvlInfo[targetNftId][token];
+        if (tvlInfo.lastUpdateIn.gtz()) {
+            return;
+        }
 
-        // update new tvl balances
-        _tvlBalance[targetNftId][token] = newBalance;
-        _tvlInDip[targetNftId][token] = newDipBalance;
+        // check target exists
+        _getAndVerifyTarget(targetNftId);
 
-        // update new amount of required dip
-        _tvlRequiredDip[targetNftId] = _tvlRequiredDip[targetNftId] - oldDipBalance + newDipBalance;
+        // check token is known for chain id of target
+        ChainId chainId = ChainIdLib.fromNftId(targetNftId);
+        if (_tokenInfo[chainId][token].lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreTokenUnknown(chainId, token);
+        }
 
-        // update last updated in
-        _tvlLastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+        // effects
+        tvlInfo.tvlAmount = AmountLib.zero();
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
 
-        emit LogStakingStoreTotalValueLockedDecreased(targetNftId, token, amount, newBalance, tvlLastUpdatedIn);
+        // add token to list of know tokens for target
+        _targetToken[targetNftId].push(token);
     }
 
-    //--- stake specific functions -------------------------------------//
 
-    function create(
-        NftId stakeNftId, 
-        IStaking.StakeInfo memory stakeInfo
+    function refillRewardReserves(
+        NftId targetNftId, 
+        Amount dipAmount
     )
         external
         restricted()
+        returns (Amount newReserveBalance)
     {
-        _create(
-            stakeNftId.toKey32(STAKE()),
-            abi.encode(stakeInfo));
+        // checks
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(targetNftId);
+        Blocknumber lastUpdateIn = targetInfo.lastUpdateIn;
 
-        _createStakeBalance(stakeNftId);
+        // effects
+        targetInfo.reserveAmount = targetInfo.reserveAmount + dipAmount;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // logging
+        newReserveBalance = targetInfo.reserveAmount;
+        emit IStaking.LogStakingRewardReservesRefilled(
+            targetNftId,
+            dipAmount,
+            _registry.ownerOf(targetNftId),
+            newReserveBalance,
+            lastUpdateIn);
     }
 
-    function update(
-        NftId stakeNftId, 
-        IStaking.StakeInfo memory stakeInfo
+
+    function withdrawRewardReserves(
+        NftId targetNftId, 
+        Amount dipAmount
     )
         external
         restricted()
+        returns (Amount newReserveBalance)
     {
-        _update(
-            stakeNftId.toKey32(STAKE()),
-            abi.encode(stakeInfo),
-            KEEP_STATE());
+        // checks
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(targetNftId);
+
+        // effects
+        Blocknumber lastUpdateIn = _decreaseReserves(targetNftId, targetInfo, dipAmount);
+
+        // logging
+        newReserveBalance = targetInfo.reserveAmount;
+        emit IStaking.LogStakingRewardReservesWithdrawn(
+            targetNftId,
+            dipAmount,
+            _registry.ownerOf(targetNftId),
+            newReserveBalance,
+            lastUpdateIn);
     }
 
-    //--- general functions --------------------------------------------//
 
+    function _spendRewardReserves(
+        NftId targetNftId, 
+        IStaking.TargetInfo storage targetInfo,
+        Amount dipAmount
+    )
+        private
+    {
+        Blocknumber lastUpdateIn = _decreaseReserves(targetNftId, targetInfo, dipAmount);
 
-    function increaseStake(
-        NftId nftId, 
+        // logging
+        emit IStaking.LogStakingRewardReservesSpent(
+            targetNftId,
+            dipAmount,
+            targetInfo.reserveAmount,
+            lastUpdateIn);
+    }
+
+
+    function _decreaseReserves(
         NftId targetNftId,
-        Amount amount
+        IStaking.TargetInfo storage targetInfo, 
+        Amount dipAmount
     )
-        external
-        restricted()
+        private
+        returns ( Blocknumber lastUpdateIn)
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
-
-        _updateStakeBalance(
-            nftId, 
-            _stakeBalance[nftId] + amount, // new stake balance
-            _rewardBalance[nftId]); // unchanged reward balance
+        lastUpdateIn = targetInfo.lastUpdateIn;
 
-        _updateTargetBalance(
-            targetNftId,
-            _stakeBalance[targetNftId] + amount,
-            _rewardBalance[targetNftId]);
+        // check if reserves are sufficient
+        if (dipAmount > targetInfo.reserveAmount) {
+            revert ErrorStakingStoreRewardReservesInsufficient(
+                targetNftId,
+                targetInfo.reserveAmount,
+                dipAmount);
+        }
 
-        emit LogStakingStoreStakesIncreased(nftId, amount, _stakeBalance[nftId], lastUpdatedIn);
+        // effects
+        targetInfo.reserveAmount = targetInfo.reserveAmount - dipAmount;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
     }
 
 
-    function restakeRewards(
-        NftId nftId, 
+    //--- tvl specific functions -------------------------------------//
+
+    function increaseTotalValueLocked(
         NftId targetNftId,
-        Amount rewardIncrementAmount
+        address token,
+        Amount amount
     )
         external
         restricted()
+        returns (Amount newBalance)
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
-        Amount stakeAmount = _stakeBalance[nftId];
-        Amount rewardAmount = _rewardBalance[nftId];
+        // checks
+        IStaking.TvlInfo storage tvlInfo = _getAndVerifyTvl(targetNftId, token);
 
-        // move all rewards to stake balance
-        _updateStakeBalance(
-            nftId, 
-            stakeAmount + rewardAmount + rewardIncrementAmount, // new stake balance
-            AmountLib.zero()); // new reward balance
+        // effects
+        tvlInfo.tvlAmount = tvlInfo.tvlAmount + amount;
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
+        newBalance = tvlInfo.tvlAmount;
+    }
 
-        _updateTargetBalance(
-            targetNftId,
-            _stakeBalance[targetNftId] + rewardAmount + rewardIncrementAmount,
-            _rewardBalance[targetNftId] - rewardAmount);
 
-        emit LogStakingStoreRewardsRestaked(nftId, stakeAmount, rewardAmount, rewardIncrementAmount, _stakeBalance[nftId], lastUpdatedIn);
+    function decreaseTotalValueLocked(
+        NftId targetNftId,
+        address token,
+        Amount amount
+    )
+        external
+        restricted()
+        returns (Amount newBalance)
+    {
+        // checks
+        IStaking.TvlInfo storage tvlInfo = _getAndVerifyTvl(targetNftId, token);
+
+        // effects
+        tvlInfo.tvlAmount = tvlInfo.tvlAmount - amount;
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
+        newBalance = tvlInfo.tvlAmount;
     }
 
+    //--- stake specific functions -------------------------------------//
 
-    function updateRewards(
-        NftId nftId, 
+    function createStake(
+        NftId stakeNftId, 
         NftId targetNftId, 
-        Amount rewardIncrementAmount
+        Amount stakedAmount
     )
         external
         restricted()
+        returns (Timestamp lockedUntil)
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
-
-        // increse rewards by increment
-        _updateStakeBalance(
-            nftId, 
-            _stakeBalance[nftId], // unchanged stake balance
-            _rewardBalance[nftId] + rewardIncrementAmount); // new reward balance
-
-        _updateTargetBalance(
+        // checks
+        lockedUntil = StakingLib.checkCreateParameters(
+            _reader,
             targetNftId,
-            _stakeBalance[targetNftId],
-            _rewardBalance[targetNftId] + rewardIncrementAmount);
+            stakedAmount);
 
-        emit LogStakingStoreRewardsIncreased(nftId, rewardIncrementAmount, _rewardBalance[nftId], lastUpdatedIn);
-    }
+        IStaking.StakeInfo storage stakeInfo = _stakeInfo[stakeNftId];
+        if (stakeInfo.lastUpdateIn.gtz()) {
+            revert ErrorStakingStoreStakeBalanceAlreadyInitialized(stakeNftId);
+        }
 
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(targetNftId);
+        _checkMaxStakedAmount(targetNftId, targetInfo, stakedAmount);
+
+        // effects
+        // update target
+        targetInfo.stakedAmount = targetInfo.stakedAmount + stakedAmount;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // update stake
+        stakeInfo.targetNftId = targetNftId;
+        stakeInfo.stakedAmount = stakedAmount;
+        stakeInfo.rewardAmount = AmountLib.zero();
+        stakeInfo.lockedUntil = lockedUntil;
+        stakeInfo.lastUpdateAt = TimestampLib.current();
+        stakeInfo.lastUpdateIn = BlocknumberLib.current();
+    }
 
-    function claimUpTo(
-        NftId nftId, 
-        NftId targetNftId, 
-        Amount maxClaimAmount
+    /// @dev Increases the stake amount and optionally restakes the rewards.
+    /// IMPORTANT: Function updateRewards must be called before this function in the same transaction.
+    function increaseStakes(
+        NftId stakeNftId, 
+        Amount stakeIncreaseAmount, // additional staked amount
+        Seconds additionalLockingPeriod, // duration to increase locked until
+        bool restakeRewards
     )
         external
         restricted()
-        returns (Amount claimedAmount)
+        returns (
+            Amount stakeBalance,
+            Amount rewardBalance,
+            Timestamp lockedUntil
+        )
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
-
-        // determine the claimable rewards amount
-        claimedAmount = AmountLib.min(maxClaimAmount, _rewardBalance[nftId]);
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _getAndVerifyStake(stakeNftId);
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(stakeInfo.targetNftId);
+        Amount restakedRewardAmount = stakeInfo.rewardAmount;
+
+        // calculate new values (with restaking)
+        if (restakeRewards && restakedRewardAmount.gtz()) {
+            Amount totalStakeIncreaseAmount = stakeIncreaseAmount + restakedRewardAmount;
+            _checkMaxStakedAmount(stakeInfo.targetNftId, targetInfo, totalStakeIncreaseAmount);
+
+            // effects
+            // update target
+            targetInfo.stakedAmount = targetInfo.stakedAmount + totalStakeIncreaseAmount;
+            targetInfo.rewardAmount = targetInfo.rewardAmount - stakeInfo.rewardAmount;
+
+            // update stake
+            stakeInfo.stakedAmount = stakeInfo.stakedAmount + totalStakeIncreaseAmount;
+            stakeInfo.rewardAmount = AmountLib.zero();
+
+        // calculate new values (without restaking)
+        } else {
+            _checkMaxStakedAmount(stakeInfo.targetNftId, targetInfo, stakeIncreaseAmount);
+    
+            // effects
+            // update target and stake
+            targetInfo.stakedAmount = targetInfo.stakedAmount + stakeIncreaseAmount;
+            stakeInfo.stakedAmount = stakeInfo.stakedAmount + stakeIncreaseAmount;
+        }
 
-        // decrease rewards by claimed amount
-        _updateStakeBalance(
-            nftId, 
-            _stakeBalance[nftId], // unchanged stake balance
-            _rewardBalance[nftId] - claimedAmount); // new reward balance
+        // update meta data for target and stake
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+        stakeInfo.lastUpdateAt = TimestampLib.current();
+        stakeInfo.lastUpdateIn = BlocknumberLib.current();
 
-        _updateTargetBalance(
-            targetNftId,
-            _stakeBalance[targetNftId],
-            _rewardBalance[targetNftId] - claimedAmount);
+        // increase locked until if applicable
+        if (additionalLockingPeriod.gtz()) {
+            stakeInfo.lockedUntil = stakeInfo.lockedUntil.addSeconds(additionalLockingPeriod);
+        }
 
-        emit LogStakingStoreRewardsDecreased(nftId, claimedAmount, _rewardBalance[nftId], lastUpdatedIn);
+        // set return values
+        stakeBalance = stakeInfo.stakedAmount;
+        rewardBalance = stakeInfo.rewardAmount;
+        lockedUntil = stakeInfo.lockedUntil;
     }
 
 
-    function unstakeUpTo(
-        NftId nftId, 
-        NftId targetNftId, 
-        Amount maxUnstakeAmount,
-        Amount maxClaimAmount
+    /// @dev Decreases the staking and reward amounts.
+    /// The function attepmts to unstake up to the specified max amounts.
+    /// In case the specified amounts are higher than the current staked and reward amounts, the avaiable amounts are unstaked.
+    /// The method optionally restakes the rewards.
+    /// IMPORTANT: Function updateRewards must be called before this function in the same transaction.
+    function decreaseStakes(
+        NftId stakeNftId, 
+        Amount maxUnstakedAmount,
+        Amount maxClaimAmount,
+        bool restakeRewards
     )
         external
         restricted()
         returns (
+            Amount restakedRewardAmount,
             Amount unstakedAmount,
-            Amount claimedAmount
+            Amount claimedAmount,
+            Amount stakeBalance,
+            Amount rewardBalance,
+            Timestamp lockedUntil
         )
     {
-        Blocknumber lastUpdatedIn = _checkBalanceExists(nftId);
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _getAndVerifyStake(stakeNftId);
+        NftId targetNftId = stakeInfo.targetNftId;
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(targetNftId);
 
-        // determine amounts
-        unstakedAmount = AmountLib.min(maxUnstakeAmount, _stakeBalance[nftId]);
-        claimedAmount = AmountLib.min(maxClaimAmount, _rewardBalance[nftId]);
+        // restake rewards if applicable
+        if (restakeRewards && stakeInfo.rewardAmount.gtz()) {
+            restakedRewardAmount = stakeInfo.rewardAmount;
+            _checkMaxStakedAmount(targetNftId, targetInfo, restakedRewardAmount);
 
-        // decrease stakes and rewards as determined
-        _updateStakeBalance(
-            nftId, 
-            _stakeBalance[nftId] - unstakedAmount, // unchanged stake balance
-            _rewardBalance[nftId] - claimedAmount); // new reward balance
+            // reserves used for restaking
+            _spendRewardReserves(targetNftId, targetInfo, restakedRewardAmount);
 
-        _updateTargetBalance(
-            targetNftId,
-            _stakeBalance[targetNftId] - unstakedAmount,
-            _rewardBalance[targetNftId] - claimedAmount);
+            // update target
+            targetInfo.stakedAmount = targetInfo.stakedAmount + restakedRewardAmount;
+            targetInfo.rewardAmount = targetInfo.rewardAmount - restakedRewardAmount;
 
-        emit LogStakingStoreStakesDecreased(nftId, unstakedAmount, _stakeBalance[nftId], lastUpdatedIn);
-        emit LogStakingStoreRewardsDecreased(nftId, claimedAmount, _rewardBalance[nftId], lastUpdatedIn);
-    }
+            // update stake
+            stakeInfo.stakedAmount = stakeInfo.stakedAmount + restakedRewardAmount;
+            stakeInfo.rewardAmount = AmountLib.zero();
 
-    //--- view functions -----------------------------------------------//
-
-    function getStakingReader() external view returns (StakingReader stakingReader){
-        return _reader;
-    }
+        } else {
+            restakedRewardAmount = AmountLib.zero();
+        }
+    
+        // determine amounts
+        unstakedAmount = AmountLib.min(maxUnstakedAmount, stakeInfo.stakedAmount);
+        claimedAmount = AmountLib.min(maxClaimAmount, stakeInfo.rewardAmount);
+
+        // update reserves if rewards are claimed
+        if (!restakeRewards) {
+            // check if reserves are sufficient
+            if (claimedAmount > targetInfo.reserveAmount) {
+                revert ErrorStakingStoreRewardReservesInsufficient(
+                    stakeInfo.targetNftId,
+                    targetInfo.reserveAmount,
+                    claimedAmount);
+            }
+
+            targetInfo.reserveAmount = targetInfo.reserveAmount - claimedAmount;
+        }
 
-    // TODO rename
-    function getTargetNftIdSet() external view returns (NftIdSet targetNftIdSet){
-        return _targetNftIdSet;
+        // update target
+        targetInfo.stakedAmount = targetInfo.stakedAmount - unstakedAmount;
+        targetInfo.rewardAmount = targetInfo.rewardAmount - claimedAmount;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // update stake
+        stakeInfo.stakedAmount = stakeInfo.stakedAmount - unstakedAmount;
+        stakeInfo.rewardAmount = stakeInfo.rewardAmount - claimedAmount;
+        stakeInfo.lastUpdateAt = TimestampLib.current();
+        stakeInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // set return values
+        stakeBalance = stakeInfo.stakedAmount;
+        rewardBalance = stakeInfo.rewardAmount;
+        lockedUntil = stakeInfo.lockedUntil;
     }
 
-    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())); }
-
-    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]; }
-
-
-    function getTargetBalances(NftId nftId)
+    function updateRewards(
+        NftId stakeNftId
+    )
         external
-        view
+        restricted()
         returns (
+            Amount rewardIncreaseAmount,
+            Seconds targetLockingPeriod,
             Amount stakeBalance,
             Amount rewardBalance,
-            Amount reserveBalance,
-            Blocknumber lastUpdatedIn
+            Timestamp lockedUntil
         )
     {
-        stakeBalance = _stakeBalance[nftId];
-        rewardBalance = _rewardBalance[nftId];
-        reserveBalance = _reserveBalance[nftId];
-        lastUpdatedIn = _lastUpdatedIn[nftId];
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _getAndVerifyStake(stakeNftId);
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(stakeInfo.targetNftId);
+
+        // get seconds since last update on stake
+        Seconds duration = SecondsLib.toSeconds(
+            block.timestamp - stakeInfo.lastUpdateAt.toInt());
+        
+        // calculate reward increase since
+        rewardIncreaseAmount = StakingLib.calculateRewardAmount(
+            targetInfo.rewardRate,
+            duration,
+            stakeInfo.stakedAmount);
+
+        // effects
+        if (rewardIncreaseAmount.gtz()) {
+            // update target
+            targetInfo.rewardAmount = targetInfo.rewardAmount + rewardIncreaseAmount;
+            targetInfo.lastUpdateIn = BlocknumberLib.current();
+
+            // update stake
+            stakeInfo.rewardAmount = stakeInfo.rewardAmount + rewardIncreaseAmount;
+            stakeInfo.lastUpdateIn = BlocknumberLib.current();
+            stakeInfo.lastUpdateAt = TimestampLib.current();
+        }
+
+        // set remaining return values
+        targetLockingPeriod = targetInfo.lockingPeriod;
+        stakeBalance = stakeInfo.stakedAmount;
+        rewardBalance = stakeInfo.rewardAmount;
+        lockedUntil = stakeInfo.lockedUntil;
     }
 
 
-    function getStakeBalances(NftId nftId)
+    function restakeRewards(
+        NftId stakeNftId,
+        Amount additionalRewardAmount, 
+        Seconds additionalLockingPeriod // duration to increase locked until
+    )
         external
-        view
+        restricted()
         returns (
-            Amount stakeBalance,
-            Amount rewardBalance,
-            Timestamp lastUpdatedAt
+            Amount newstakedAmount
         )
     {
-        stakeBalance = _stakeBalance[nftId];
-        rewardBalance = _rewardBalance[nftId];
-        lastUpdatedAt = _lastUpdatedAt[nftId];
+        // checks
+        IStaking.StakeInfo storage stakeInfo = _getAndVerifyStake(stakeNftId);
+
+        Amount oldRewardAmount = stakeInfo.rewardAmount;
+        Amount updatedRewardAmount = stakeInfo.rewardAmount + additionalRewardAmount;
+
+        IStaking.TargetInfo storage targetInfo = _getAndVerifyTarget(stakeInfo.targetNftId);
+        _checkMaxStakedAmount(stakeInfo.targetNftId, targetInfo, updatedRewardAmount);
+
+        // effects
+        // update target
+        targetInfo.stakedAmount = targetInfo.stakedAmount + updatedRewardAmount;
+        targetInfo.rewardAmount = targetInfo.rewardAmount - oldRewardAmount;
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // update stake
+        stakeInfo.stakedAmount = stakeInfo.stakedAmount + updatedRewardAmount;
+        stakeInfo.rewardAmount = AmountLib.zero();
+        stakeInfo.lastUpdateAt = TimestampLib.current();
+        stakeInfo.lastUpdateIn = BlocknumberLib.current();
+
+        // increase locked until if applicable
+        if (additionalLockingPeriod.gtz()) {
+            stakeInfo.lockedUntil.addSeconds(additionalLockingPeriod);
+        }
     }
 
-    //--- private functions -------------------------------------------//
 
-    function _createTarget(
-        NftId targetNftId,
-        IStaking.TargetInfo memory targetInfo
-    )
-        private
-    {
-        _create(
-            targetNftId.toKey32(TARGET()),
-            abi.encode(targetInfo));
+    //--- view functions -----------------------------------------------//
 
-        // initialize tvl and stake balance
-        _tvlLastUpdatedIn[targetNftId]= BlocknumberLib.currentBlocknumber();
-        _createTargetBalance(targetNftId);
+    function getStakingReader() external view returns (StakingReader stakingReader){
+        return _reader;
+    }
 
-        _targetNftIdSet.add(targetNftId);
+
+    function exists(NftId stakeNftId) external view returns (bool) { 
+        return _stakeInfo[stakeNftId].lastUpdateIn.gtz();
     }
 
-    function _updateReserves(
-        NftId targetNftId, 
-        Amount newRewardBalance
-    )
-        private
-        returns (Blocknumber lastUpdatedIn)
+
+    function getRequiredStakeBalance(NftId targetNftId)
+        external
+        view
+        returns (Amount requiredStakedAmount)
     {
-        if (_lastUpdatedIn[targetNftId].eqz()) {
-            revert ErrorStakingStoreNotTarget(targetNftId);
+        address [] memory tokens = _targetToken[targetNftId];
+        if (tokens.length == 0) {
+            return AmountLib.zero();
         }
 
-        lastUpdatedIn = _lastUpdatedIn[targetNftId];
+        requiredStakedAmount = AmountLib.zero();
+        ChainId targetChainId = _targetInfo[targetNftId].chainId;
+        address token;
+        Amount tvlAmount;
+        UFixed stakingRate;
 
-        _reserveBalance[targetNftId] = newRewardBalance;
-        _lastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
-    }
+        for (uint256 i = 0; i < tokens.length; i++) {
+            token = tokens[i];
+            tvlAmount = _tvlInfo[targetNftId][token].tvlAmount;
+            if (tvlAmount.eqz()) { continue; }
 
+            stakingRate = _tokenInfo[targetChainId][token].stakingRate;
+            if (stakingRate.eqz()) { continue; }
 
-    function _createTargetBalance(NftId nftId)
-        private
-    {
-        if (_lastUpdatedIn[nftId].gtz()) {
-            revert ErrorStakingStoreBalanceAlreadyInitialized(nftId);
+            requiredStakedAmount = requiredStakedAmount + tvlAmount.multiplyWith(stakingRate);
         }
+    }
+
+
+    /// @dev Returns true iff current stake amount is still locked
+    function isStakeLocked(NftId stakeNftId) external view returns (bool) { 
+        return _stakeInfo[stakeNftId].lockedUntil > TimestampLib.current(); 
+    }
+
+
+    /// @dev Returns the stake infos for the specified stake.
+    function getStakeInfo(NftId stakeNftId) external view returns (IStaking.StakeInfo memory stakeInfo) { 
+        return _stakeInfo[stakeNftId]; 
+    }
+
+
+    /// @dev Returns the stake infos for the specified stake.
+    function getStakeTarget(NftId stakeNftId) external view returns (NftId targetNftId) { 
+        return _stakeInfo[stakeNftId].targetNftId; 
+    }
+
+
+    /// @dev Returns the target infos for the specified target.
+    function getTargetInfo(NftId targetNftId) external view returns (IStaking.TargetInfo memory targetInfo) { 
+        return _targetInfo[targetNftId]; 
+    }
+
+
+    /// @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];
+    }
 
-        // set target balances to 0
-        _stakeBalance[nftId] = AmountLib.zero();
-        _rewardBalance[nftId] = AmountLib.zero();
-        _reserveBalance[nftId] = AmountLib.zero();
 
-        // set last updated in to current block number
-        // we don't need last updated at timestamp for targets
-        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+    function getTargetSet() external view returns (NftIdSet targetNftIdSet) { 
+        return _targetNftIdSet;
     }
 
 
-    function _createStakeBalance(NftId nftId)
+    //--- private stake and target functions --------------------------------//
+
+
+    function _getAndVerifyStake(
+        NftId stakeNftId
+    )
         private
+        view
+        returns (
+            IStaking.StakeInfo storage stakeInfo
+        )
     {
-        if (_lastUpdatedIn[nftId].gtz()) {
-            revert ErrorStakingStoreBalanceAlreadyInitialized(nftId);
+        stakeInfo = _stakeInfo[stakeNftId];
+        if (stakeInfo.lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreStakeNotInitialized(stakeNftId);
         }
-
-        // set stake balances to 0
-        _stakeBalance[nftId] = AmountLib.zero();
-        _rewardBalance[nftId] = AmountLib.zero();
-
-        // set last updated at/in to current timestamp/block number
-        _lastUpdatedAt[nftId] = TimestampLib.blockTimestamp();
-        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
     }
 
 
-    function _updateStakeBalance(
-        NftId stakeNftId,
-        Amount newStakeAmount,
-        Amount newRewardAmount
+    function _checkMaxStakedAmount(
+        NftId targetNftId, 
+        IStaking.TargetInfo storage targetInfo, 
+        Amount additionalstakedAmount
     )
         private
     {
-        _stakeBalance[stakeNftId] = newStakeAmount;
-        _rewardBalance[stakeNftId] = newRewardAmount;
+        if (targetInfo.stakedAmount + additionalstakedAmount > targetInfo.maxStakedAmount) {
+            revert ErrorStakingStoreStakesExceedingTargetMaxAmount(
+                targetNftId,
+                targetInfo.maxStakedAmount,
+                targetInfo.stakedAmount + additionalstakedAmount);
+        }
 
-        _lastUpdatedAt[stakeNftId] = TimestampLib.blockTimestamp();
-        _lastUpdatedIn[stakeNftId] = BlocknumberLib.currentBlocknumber();
+        // TODO add check for tvl dependent maximum, see #628
     }
 
 
-    function _updateTargetBalance(
-        NftId targetNftId,
-        Amount newStakeAmount,
-        Amount newRewardAmount
+    function _getAndVerifyTarget(
+        NftId targetNftId
     )
         private
+        view
+        returns (
+            IStaking.TargetInfo storage targetInfo
+        )
     {
-        _stakeBalance[targetNftId] = newStakeAmount;
-        _rewardBalance[targetNftId] = newRewardAmount;
+        targetInfo = _targetInfo[targetNftId];
 
-        // for targets we don't need the timestamp, just the blocknumber
-        _lastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+        if (targetInfo.lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreTargetNotInitialized(targetNftId);
+        }
     }
 
-    function _checkBalanceExists(NftId nftId)
+    //--- private tvl functions ------------------------------------------------//
+
+    /// @dev Initializes token balance handling for the specified target.
+    function _createTvlBalance(NftId targetNftId, address token)
         private
-        view
-        returns (Blocknumber lastUpdatedIn)
     {
-        lastUpdatedIn = _lastUpdatedIn[nftId];
+        IStaking.TvlInfo storage info = _tvlInfo[targetNftId][token];
 
-        if (lastUpdatedIn.eqz()) {
-            revert ErrorStakingStoreBalanceNotInitialized(nftId);
+        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 _getAndVerifyTvl(
+    function _updateTvlBalance(
         NftId targetNftId,
-        address token
+        address token,
+        Amount newTvlAmount
     )
         private
-        view
         returns (
-            Blocknumber tvlLastUpdatedIn,
-            Amount oldBalance,
-            Amount oldDipBalance
+            Amount oldTvlAmount,
+            Blocknumber lastUpdatedIn
         )
     {
-        tvlLastUpdatedIn = _tvlLastUpdatedIn[targetNftId];
+        IStaking.TvlInfo storage tvlInfo = _getAndVerifyTvl(targetNftId, token);
+        oldTvlAmount = tvlInfo.tvlAmount;
+        lastUpdatedIn = tvlInfo.lastUpdateIn;
+
+        tvlInfo.tvlAmount = newTvlAmount;
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
+    }
 
-        if (tvlLastUpdatedIn.eqz()) {
-            revert ErrorStakingStoreTvlBalanceNotInitialized(targetNftId);
-        }
 
-        oldBalance = _tvlBalance[targetNftId][token];
-        oldDipBalance = _tvlInDip[targetNftId][token];
+    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);
+        }
     }
 }