@etherisc/gif-next 0.0.2-e79d227-681 → 0.0.2-e7a5428-226

package/contracts/staking/StakingStore.sol

@@ -7,17 +7,20 @@ import {IRegistry} from "../registry/IRegistry.sol";
 import {IStaking} from "./IStaking.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} 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 {StakingLifecycle} from "./StakingLifecycle.sol";
-import {UFixed} from "../type/UFixed.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
 
 
 contract StakingStore is 
@@ -26,51 +29,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);
-
-    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);
+    // token
+    error ErrorStakingStoreTokenNotRegistered(ChainId chainId, address token);
+    error ErrorStakingStoreTokenAlreadyAdded(ChainId chainId, address token);
+    error ErrorStakingStoreTokenUnknown(ChainId chainId, address token);
 
-    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) private _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)
@@ -80,61 +76,183 @@ 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();
+
+        // logging
+        emit IStaking.LogStakingTokenAdded(chainId, token);
+    }
+
 
+    /// @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() // staking
+        returns (
+            Seconds oldLockingPeriod,
+            Blocknumber lastUpdatedIn
+        )
+    {
+        TargetManagerLib.checkLockingPeriod(targetNftId, lockingPeriod);
+
+        IStaking.TargetInfo storage targetInfo;
+        (targetInfo, lastUpdatedIn) = _verifyAndUpdateTarget(targetNftId);
+
+        oldLockingPeriod = targetInfo.lockingPeriod;
+        targetInfo.lockingPeriod = lockingPeriod;
+    }
+
+
+    function setRewardRate(
+        NftId targetNftId,
+        UFixed rewardRate
+    )
+        external
+        restricted() // staking
+        returns (
+            UFixed oldRewardRate,
+            Blocknumber lastUpdatedIn
+        )
+    {
+        TargetManagerLib.checkRewardRate(targetNftId, rewardRate);
+
+        IStaking.TargetInfo storage targetInfo;
+        (targetInfo, lastUpdatedIn) = _verifyAndUpdateTarget(targetNftId);
+
+        oldRewardRate = targetInfo.rewardRate;
+        targetInfo.rewardRate = rewardRate;
+    }
+
+
+    function setMaxStakedAmount(
+        NftId targetNftId,
+        Amount maxStakedAmount
+    )
+        external
+        restricted() // staking
+        returns (
+            Amount oldMaxStakedAmount,
+            Blocknumber lastUpdatedIn
+        )
+    {
+        IStaking.TargetInfo storage targetInfo;
+        (targetInfo, lastUpdatedIn) = _verifyAndUpdateTarget(targetNftId);
+
+        oldMaxStakedAmount = targetInfo.maxStakedAmount;
+        targetInfo.maxStakedAmount = maxStakedAmount;
+    }
+
+
+    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
     )
@@ -142,14 +260,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
     )
@@ -157,18 +287,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);
     }
 
 
@@ -176,7 +308,6 @@ contract StakingStore is
 
     function increaseTotalValueLocked(
         NftId targetNftId,
-        UFixed stakingRate,
         address token,
         Amount amount
     )
@@ -184,32 +315,18 @@ contract StakingStore is
         restricted()
         returns (Amount newBalance)
     {
-        (
-            Blocknumber tvlLastUpdatedIn,
-            Amount oldBalance,
-            Amount oldDipBalance
-        ) = _getAndVerifyTvl(targetNftId, token);
-
-        newBalance = oldBalance + amount;
-        Amount newDipBalance = newBalance.multiplyWith(stakingRate);
+        // checks
+        IStaking.TvlInfo storage tvlInfo = _getAndVerifyTvl(targetNftId, token);
 
-        // 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);
+        // effects
+        tvlInfo.tvlAmount = tvlInfo.tvlAmount + amount;
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
+        newBalance = tvlInfo.tvlAmount;
     }
 
 
     function decreaseTotalValueLocked(
         NftId targetNftId,
-        UFixed stakingRate,
         address token,
         Amount amount
     )
@@ -217,389 +334,640 @@ contract StakingStore is
         restricted()
         returns (Amount newBalance)
     {
-        (
-            Blocknumber tvlLastUpdatedIn,
-            Amount oldBalance,
-            Amount oldDipBalance
-        ) = _getAndVerifyTvl(targetNftId, token);
-
-        newBalance = oldBalance - amount;
-        Amount newDipBalance = AmountLib.toAmount((
-            stakingRate * newBalance.toUFixed()).toInt());
+        // checks
+        IStaking.TvlInfo storage tvlInfo = _getAndVerifyTvl(targetNftId, token);
 
-        // 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 LogStakingStoreTotalValueLockedDecreased(targetNftId, token, amount, newBalance, tvlLastUpdatedIn);
+        // effects
+        tvlInfo.tvlAmount = tvlInfo.tvlAmount - amount;
+        tvlInfo.lastUpdateIn = BlocknumberLib.current();
+        newBalance = tvlInfo.tvlAmount;
     }
 
     //--- 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);
+
+        // 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);
 
-        _createStakeBalance(stakeNftId);
+        // process stake amount
+        _stake(stakeNftId, stakeInfo, targetInfo, targetInfo.lockingPeriod, stakeAmount);
     }
 
-    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 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)
         external
-        restricted()
-        returns (
-            Amount unstakedAmount,
-            Amount claimedAmount
-        )
+        view
+        returns (Amount requiredStakedAmount)
     {
-        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]);
+        requiredStakedAmount = 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; }
 
-        emit LogStakingStoreStakesDecreased(nftId, unstakedAmount, _stakeBalance[nftId], lastUpdatedIn);
-        emit LogStakingStoreRewardsDecreased(nftId, claimedAmount, _rewardBalance[nftId], lastUpdatedIn);
+            requiredStakedAmount = requiredStakedAmount + tvlAmount.multiplyWith(stakingRate);
+        }
     }
 
-    //--- 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 tvl infos for the specified target.
+    function getTvlInfo(NftId targetNftId, address token) external view returns (IStaking.TvlInfo memory tvlInfo) {
+        return _tvlInfo[targetNftId][token];
     }
 
 
-    function getStakeBalances(NftId nftId)
-        external
-        view
+    /// @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 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));
+        // checks
+        if (checkParameters) {
+            TargetManagerLib.checkTargetParameters(
+                _registry, 
+                _reader, 
+                targetNftId, 
+                objectType, 
+                lockingPeriod, 
+                rewardRate);
+        }
+
+        // effects
+        IStaking.TargetInfo storage targetInfo = _targetInfo[targetNftId];
+        targetInfo.stakedAmount = AmountLib.zero();
+        targetInfo.rewardAmount = AmountLib.zero();
+        targetInfo.reserveAmount = AmountLib.zero();
+        targetInfo.maxStakedAmount = AmountLib.max();
 
-        // initialize tvl and stake balance
-        _tvlLastUpdatedIn[targetNftId]= BlocknumberLib.currentBlocknumber();
-        _createTargetBalance(targetNftId);
+        targetInfo.objectType = objectType;
+        targetInfo.lockingPeriod = lockingPeriod;
+        targetInfo.rewardRate = rewardRate;
+        targetInfo.chainId = ChainIdLib.fromNftId(targetNftId);
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
 
+        // add new target to target set
         _targetNftIdSet.add(targetNftId);
     }
 
-    function _updateReserves(
+
+    function _spendRewardReserves(
         NftId targetNftId, 
-        Amount newRewardBalance
+        IStaking.TargetInfo storage targetInfo,
+        Amount dipAmount
     )
         private
-        returns (Blocknumber lastUpdatedIn)
     {
-        if (_lastUpdatedIn[targetNftId].eqz()) {
-            revert ErrorStakingStoreNotTarget(targetNftId);
-        }
+        Blocknumber lastUpdateIn = _decreaseReserves(targetNftId, targetInfo, dipAmount);
 
-        lastUpdatedIn = _lastUpdatedIn[targetNftId];
-
-        _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;
+        _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingStakeRewardsUpdated(
+            stakeNftId, 
+            rewardIncreaseAmount, 
+            stakeInfo.stakedAmount, 
+            stakeInfo.rewardAmount, 
+            stakeInfo.lockedUntil);
     }
 
 
-    function _createStakeBalance(NftId nftId)
-        private
+    function _restakeRewards(
+        NftId stakeNftId,
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo
+    )
+        internal
+        returns (Amount restakeAmount)
+    {
+        restakeAmount = stakeInfo.rewardAmount;
+
+        // return if reward amount is zero
+        if (restakeAmount.eqz()) {
+            return restakeAmount;
+        }
+
+        // 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();
+        _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingRewardsRestaked(
+            stakeNftId,
+            restakeAmount, 
+            stakeInfo.stakedAmount, 
+            AmountLib.zero(), 
+            stakeInfo.lockedUntil);
+    }
+
+
+    function _stake(
+        NftId stakeNftId,
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo,
+        Seconds maxAdditionalLockingPeriod,
+        Amount stakeAmount
+    )
+        internal
     {
-        if (_lastUpdatedIn[nftId].gtz()) {
-            revert ErrorStakingStoreBalanceAlreadyInitialized(nftId);
+        // return if reward amount is zero
+        if (stakeAmount.eqz()) {
+            return;
         }
 
-        // 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, stakeAmount);
+
+        // update target + stake
+        targetInfo.stakedAmount = targetInfo.stakedAmount + stakeAmount;
+        stakeInfo.stakedAmount = stakeInfo.stakedAmount + stakeAmount;
 
-        // set last updated at/in to current timestamp/block number
-        _lastUpdatedAt[nftId] = TimestampLib.blockTimestamp();
-        _lastUpdatedIn[nftId] = BlocknumberLib.currentBlocknumber();
+        // increase locked until if applicable
+        Seconds additionalLockingPeriod = SecondsLib.min(maxAdditionalLockingPeriod, targetInfo.lockingPeriod);
+        if (stakeAmount.gtz() && additionalLockingPeriod.gtz()) {
+            stakeInfo.lockedUntil = stakeInfo.lockedUntil.addSeconds(additionalLockingPeriod);
+        }
+
+        _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingStaked(
+            stakeNftId,
+            stakeAmount, 
+            stakeInfo.stakedAmount, 
+            stakeInfo.rewardAmount, 
+            stakeInfo.lockedUntil);
     }
 
 
-    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)
     {
-        _stakeBalance[stakeNftId] = newStakeAmount;
-        _rewardBalance[stakeNftId] = newRewardAmount;
+        claimAmount = AmountLib.min(maxClaimAmount, stakeInfo.rewardAmount);
 
-        _lastUpdatedAt[stakeNftId] = TimestampLib.blockTimestamp();
-        _lastUpdatedIn[stakeNftId] = BlocknumberLib.currentBlocknumber();
+        // 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;
+        _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingRewardsClaimed(
+            stakeNftId,
+            claimAmount, 
+            stakeInfo.stakedAmount, 
+            stakeInfo.rewardAmount, 
+            stakeInfo.lockedUntil);
     }
 
 
-    function _updateTargetBalance(
-        NftId targetNftId,
-        Amount newStakeAmount,
-        Amount newRewardAmount
+    function _unstake(
+        NftId stakeNftId,
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo,
+        Amount maxUnstakeAmount
     )
-        private
+        internal
+        returns (Amount unstakedAmount)
     {
-        _stakeBalance[targetNftId] = newStakeAmount;
-        _rewardBalance[targetNftId] = newRewardAmount;
+        unstakedAmount = AmountLib.min(maxUnstakeAmount, stakeInfo.stakedAmount);
+
+        // return if no stakes to claim
+        if (unstakedAmount.eqz()) {
+            return unstakedAmount;
+        }
+
+        // check if stake is still locked
+        if (isStakeLocked(stakeNftId)) {
+            revert IStaking.ErrorStakingStakeLocked(stakeNftId, stakeInfo.lockedUntil);
+        }
 
-        // for targets we don't need the timestamp, just the blocknumber
-        _lastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+        // update target + stake
+        targetInfo.stakedAmount = targetInfo.stakedAmount - unstakedAmount;
+        stakeInfo.stakedAmount = stakeInfo.stakedAmount - unstakedAmount;
+        _setLastUpdatesToCurrent(stakeInfo, targetInfo);
+
+        // logging
+        emit IStaking.LogStakingUnstaked(
+            stakeNftId,
+            unstakedAmount, 
+            stakeInfo.stakedAmount, 
+            stakeInfo.rewardAmount, 
+            stakeInfo.lockedUntil);
     }
 
-    function _checkBalanceExists(NftId nftId)
+
+    function _setLastUpdatesToCurrent(
+        IStaking.StakeInfo storage stakeInfo,
+        IStaking.TargetInfo storage targetInfo
+    )
+        internal
+    {
+        targetInfo.lastUpdateIn = BlocknumberLib.current();
+        _setStakeLastUpdatesToCurrent(stakeInfo);
+    }
+
+
+    function _setStakeLastUpdatesToCurrent(
+        IStaking.StakeInfo storage stakeInfo
+    )
+        internal
+    {
+        stakeInfo.lastUpdateIn = BlocknumberLib.current();
+        stakeInfo.lastUpdateAt = TimestampLib.current();
+    }
+
+    //--- private stake and target functions --------------------------------//
+
+
+    function _getAndVerifyStake(
+        NftId stakeNftId
+    )
         private
         view
-        returns (Blocknumber lastUpdatedIn)
+        returns (
+            IStaking.StakeInfo storage stakeInfo
+        )
     {
-        lastUpdatedIn = _lastUpdatedIn[nftId];
+        stakeInfo = _stakeInfo[stakeNftId];
+        if (stakeInfo.lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreStakeNotInitialized(stakeNftId);
+        }
+    }
 
-        if (lastUpdatedIn.eqz()) {
-            revert ErrorStakingStoreBalanceNotInitialized(nftId);
+
+    function _checkMaxStakedAmount(
+        NftId targetNftId, 
+        IStaking.TargetInfo storage targetInfo, 
+        Amount additionalstakedAmount
+    )
+        private
+    {
+        if (targetInfo.stakedAmount + additionalstakedAmount > targetInfo.maxStakedAmount) {
+            revert IStaking.ErrorStakingTargetMaxStakedAmountExceeded(
+                targetNftId,
+                targetInfo.maxStakedAmount,
+                targetInfo.stakedAmount + additionalstakedAmount);
         }
+
+        // TODO add check for tvl dependent maximum, see #628
     }
 
 
-    function _getAndVerifyTvl(
-        NftId targetNftId,
-        address token
+    function _getAndVerifyTarget(
+        NftId targetNftId
     )
         private
         view
         returns (
-            Blocknumber tvlLastUpdatedIn,
-            Amount oldBalance,
-            Amount oldDipBalance
+            IStaking.TargetInfo storage targetInfo
         )
     {
-        tvlLastUpdatedIn = _tvlLastUpdatedIn[targetNftId];
+        targetInfo = _targetInfo[targetNftId];
 
-        if (tvlLastUpdatedIn.eqz()) {
-            revert ErrorStakingStoreTvlBalanceNotInitialized(targetNftId);
+        if (targetInfo.lastUpdateIn.eqz()) {
+            revert ErrorStakingStoreTargetNotInitialized(targetNftId);
         }
+    }
+
+    //--- private tvl functions ------------------------------------------------//
+
+    /// @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();
+    }
+
 
-        oldBalance = _tvlBalance[targetNftId][token];
-        oldDipBalance = _tvlInDip[targetNftId][token];
+    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);
+        }
     }
 }