@etherisc/gif-next 0.0.2-da2c7dd-538 → 0.0.2-da87b00-860

package/contracts/staking/IStaking.sol

@@ -1,165 +1,367 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Amount} from "../type/Amount.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
 import {IComponent} from "../shared/IComponent.sol";
 import {IVersionable} from "../upgradeability/IVersionable.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {Blocknumber} from "../type/Blocknumber.sol";
+import {ChainId} from "../type/ChainId.sol";
 import {NftId} from "../type/NftId.sol";
 import {ObjectType} from "../type/ObjectType.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {StakingReader} from "./StakingReader.sol";
 import {StakingStore} from "./StakingStore.sol";
+import {TargetHandler} from "./TargetHandler.sol";
 import {Timestamp} from "../type/Timestamp.sol";
 import {UFixed} from "../type/UFixed.sol";
+import {VersionPart} from "../type/Version.sol";
+
 
 interface IStaking is 
     IComponent,
     IVersionable
 {
-    // staking rate
-    event LogStakingStakingRateSet(uint256 chainId, address token, UFixed oldStakingRate, UFixed newStakingRate);
+
+    // owner functions
+    event LogStakingStakingRateSet(ChainId chainId, address token, UFixed newStakingRate, UFixed oldStakingRate, Blocknumber lastUpdateIn);
+    event LogStakingStakingServiceSet(address stakingService, VersionPart release, address oldStakingService);
+    event LogStakingStakingReaderSet(address stakingReader, address oldStakingReader);
+    event LogStakingTargetHandlerSet(address targetManager, address oldTargetHandler);
+    event LogStakingTokenHandlerApproved(address token, Amount approvalAmount, Amount oldApprovalAmount);
+
+    // token
+    event LogStakingTokenAdded(ChainId chainId, address token);
+    event LogStakingTargetTokenAdded(NftId targetNftId, ChainId chainId, address token);
+
+    // total value locked
+    event LogStakingTvlIncreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdateIn);
+    event LogStakingTvlDecreased(NftId targetNftId, address token, Amount amount, Amount newBalance, Blocknumber lastUpdateIn);
+
+    // targets
+    event LogStakingSupportInfoSet(
+        ObjectType objectType,
+        bool isSupported,
+        bool allowNewTargets,
+        bool allowCrossChain,
+        Amount minStakingAmount,
+        Amount maxStakingAmount,
+        Seconds minLockingPeriod,
+        Seconds maxLockingPeriod,
+        UFixed minRewardRate,
+        UFixed maxRewardRate,
+        Blocknumber lastUpdateIn);
+
+    event LogStakingTargetCreated(NftId targetNftId, ObjectType objectType, Seconds lockingPeriod, UFixed rewardRate);
+    event LogStakingLimitsSet(NftId targetNftId, Amount marginAmount, Amount hardLimitAmount, Blocknumber lastUpdateIn);
+    event LogStakingTargetLimitsUpdated(NftId targetNftId, Amount marginAmount, Amount hardLimitAmount, Blocknumber lastUpdateIn);
+    event LogStakingTargetLimitUpdated(NftId targetNftId, Amount limitAmount, Amount hardLimitAmount, Amount requiredStakeAmount, Amount actualStakeAmount, Blocknumber lastUpdateIn);
 
     // target parameters
-    event LogStakingLockingPeriodSet(NftId targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod);
-    event LogStakingRewardRateSet(NftId targetNftId, UFixed oldRewardRate, UFixed rewardRate);
+    event LogStakingTargetLockingPeriodSet(NftId targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod, Blocknumber lastUpdateIn);
+    event LogStakingTargetRewardRateSet(NftId targetNftId, UFixed rewardRate, UFixed oldRewardRate, Blocknumber lastUpdateIn);
+    // TODO cleanup LogStakingTargetMaxStakedAmountSet
+    event LogStakingTargetMaxStakedAmountSet(NftId targetNftId, Amount stakeLimitAmount, Blocknumber lastUpdateIn);
+    event LogStakingTargetLimitsSet(NftId targetNftId, Amount stakeLimitAmount, Amount marginAmount, Amount limitAmount);
+
+    // reward reserves
+    event LogStakingRewardReservesRefilled(NftId targetNftId, Amount dipAmount, address targetOwner, Amount reserveBalance, Blocknumber lastUpdateIn);
+    event LogStakingRewardReservesWithdrawn(NftId targetNftId, Amount dipAmount, address targetOwner, Amount reserveBalance, Blocknumber lastUpdateIn);
+    event LogStakingRewardReservesSpent(NftId targetNftId, Amount dipAmount, Amount reserveBalance, Blocknumber lastUpdateIn);
+
+    // stakes
+    event LogStakingStakeCreated(NftId stakeNftId, NftId targetNftId, Amount stakeAmount, Timestamp lockedUntil, address stakeOwner);
+    event LogStakingStakeRewardsUpdated(NftId stakeNftId, Amount rewardIncrementAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+    event LogStakingRewardsRestaked(NftId stakeNftId, Amount restakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+    event LogStakingStaked(NftId stakeNftId, Amount stakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+    event LogStakingUnstaked(NftId stakeNftId, Amount unstakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+    event LogStakingRewardsClaimed(NftId stakeNftId, Amount claimedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil, Blocknumber lastUpdateIn);
+
+    event LogStakingStakeRestaked(NftId stakeNftId, NftId targetNftId, Amount stakeAmount, address owner, NftId oldStakeNftId);
 
     // modifiers
     error ErrorStakingNotStake(NftId stakeNftId);
     error ErrorStakingNotTarget(NftId targetNftId);
+    error ErrorStakingNotOwner(NftId stakeNftId, address expectedOwner, address actualOwner);
 
     error ErrorStakingNotStakingOwner();
     error ErrorStakingNotNftOwner(NftId nftId);
 
+    // owner functions
+    error ErrorStakingReleaseNotActive(VersionPart release);
+    error ErrorStakingServiceNotFound(VersionPart release);
+
     // initializeTokenHandler
     error ErrorStakingNotRegistry(address registry);
 
     // staking rate
-    error ErrorStakingTokenNotRegistered(uint256 chainId, address token);
+    error ErrorStakingTokenNotRegistered(ChainId chainId, address token);
 
     // check dip balance and allowance
     error ErrorStakingDipBalanceInsufficient(address owner, uint256 amount, uint256 dipBalance);
     error ErrorStakingDipAllowanceInsufficient(address owner, address tokenHandler, uint256 amount, uint256 dipAllowance);
 
     error ErrorStakingStakingReaderStakingMismatch(address stakingByStakingReader);
+
+    // target management
+    error ErrorStakingSupportTypeInvalid(ObjectType targetType);
+    error ErrorStakingStakingAmountsInvalid(Amount minStakingAmount, Amount maxStakingAmount);
+    error ErrorStakingLockingPeriodsInvalid(Seconds minLockingPeriod, Seconds maxLockingPeriod);
+    error ErrorStakingRewardRatesInvalid(UFixed minRewardRate, UFixed maxRewardRate);
+
+    error ErrorStakingTargetNotFound(NftId targetNftId);
+    error ErrorStakingTargetTokenNotFound(NftId targetNftId, ChainId chainId, address token);
+    error ErrorStakingTargetMaxStakedAmountExceeded(NftId targetNftId, Amount stakeLimitAmount, Amount stakedAmount);
+
     error ErrorStakingTargetAlreadyRegistered(NftId targetNftId);
     error ErrorStakingTargetNftIdZero();
     error ErrorStakingTargetTypeNotSupported(NftId targetNftId, ObjectType objectType);
+    error ErrorStakingCrossChainTargetsNotSupported(NftId targetNftId, ObjectType objectType);
     error ErrorStakingTargetUnexpectedObjectType(NftId targetNftId, ObjectType expectedObjectType, ObjectType actualObjectType);
-    error ErrorStakingLockingPeriodTooShort(NftId targetNftId, Seconds minLockingPeriod, Seconds lockingPeriod);
-    error ErrorStakingLockingPeriodTooLong(NftId targetNftId, Seconds maxLockingPeriod, Seconds lockingPeriod);
-    error ErrorStakingStakeLocked(NftId stakeNftId, Timestamp lockedUntil);
-    error ErrorStakingRewardRateTooHigh(NftId targetNftId, UFixed maxRewardRate, UFixed rewardRate);
-    error ErrorStakingTargetNotFound(NftId targetNftId);
-    error ErrorStakingTargetTokenNotFound(NftId targetNftId, uint256 chainId, address token);
+    error ErrorStakingLockingPeriodInvalid(NftId targetNftId, Seconds lockingPeriod, Seconds minLockingPeriod, Seconds maxLockingPeriod);
+    error ErrorStakingRewardRateInvalid(NftId targetNftId, UFixed rewardRate, UFixed minRewardRate, UFixed maxRewardRate);
 
-    error ErrorStakingTargetNotActive(NftId targetNftId);
+    error ErrorStakingStakeLocked(NftId stakeNftId, Timestamp lockedUntil);
     error ErrorStakingStakeAmountZero(NftId targetNftId);
 
     // info for individual stake
     struct StakeInfo {
-        Timestamp lockedUntil;
+        // slot 0
+        Amount stakedAmount; // 96
+        Amount rewardAmount; // 96
+        Timestamp lockedUntil; // 40
+        // slot 1
+        NftId targetNftId; // 96, redundant to parent nft in registry object info
+        Timestamp lastUpdateAt; // 40, needed to update rewards
+        Blocknumber lastUpdateIn; // 40, needed for traceability
+    }
+
+
+    struct SupportInfo {
+        bool isSupported; // 1
+        bool allowNewTargets;
+        bool allowCrossChain;
+
+        Amount minStakingAmount; // 96
+        Amount maxStakingAmount; // 96
+
+        Seconds minLockingPeriod; // 40
+        Seconds maxLockingPeriod; // 40
+
+        UFixed minRewardRate; // 160
+        UFixed maxRewardRate; // 160
+
+        Blocknumber lastUpdateIn; // 40, needed for traceability
     }
 
+
     struct TargetInfo {
-        ObjectType objectType;
-        uint256 chainId;
-        Seconds lockingPeriod;
-        UFixed rewardRate;
+        // Slot 0
+        Amount stakedAmount; // 96
+        Amount rewardAmount; // 96
+        Blocknumber lastUpdateIn; // 40, needed for traceability
+        // Slot 1
+        Amount reserveAmount; // 96
+        Amount limitAmount; // 96
+        Seconds lockingPeriod; // 40
+        ObjectType objectType; // 8
+        // Slot 2
+        UFixed rewardRate; // 160
+        ChainId chainId; // 96 redundant to target nft id
+    }
+
+    struct LimitInfo {
+        // Slot 0
+        Amount marginAmount; // 96
+        Amount hardLimitAmount; // 96
+        Blocknumber lastUpdateIn; // 40, needed for traceability
+    }
+
+    struct TvlInfo {
+        // Slot 0
+        Amount tvlAmount; // 96
+        Amount tvlBaselineAmount; // 96
+        uint16 updatesCounter; // 8
+        Blocknumber lastUpdateIn; // 40, needed for traceability
+    }
+
+    struct TokenInfo {
+        // Slot 0
+        UFixed stakingRate; // 160
+        Blocknumber lastUpdateIn; // 40, needed for traceability
     }
 
     function initializeTokenHandler() external;
 
-    // staking rate management 
+    //--- only owner functions ----------------------------------------------//
+
+    /// @dev Enable/disable the staking support for the specified target type.
+    /// Defines the degrees of freedom for creating staking targets per target type.
+    function setSupportInfo(
+        ObjectType targetType,
+        bool isSupported,
+        bool allowNewTargets,
+        bool allowCrossChain,
+        Amount minStakingAmount,
+        Amount maxStakingAmount,
+        Seconds minLockingPeriod,
+        Seconds maxLockingPeriod,
+        UFixed minRewardRate,
+        UFixed maxRewardRate
+    ) external;
 
-    /// @dev sets the rate that converts 1 token of total value locked into the
-    /// the required staked dip amount to back up the locked token value
-    function setStakingRate(uint256 chainId, address token, UFixed stakingRate) external;
+    /// @dev Set the trigger values to determine when to update limit amount in TargetInfo.
+    /// Changes in the TvlInfo may trigger an update of the limit amount in the TargetInfo based on these settings.
+    /// The value tvlUpdatesTrigger suppresses any updates if the number of TVL updates is below this value.
+    /// The value minTvlRatioTrigger defines the minimal TVL ratio above which the limit amount is updated.
+    /// The ratio is calulated as current TVL / baseline TVL (or baseline TVL / current TVL).
+    function setUpdateTriggers(
+        uint16 tvlUpdatesTrigger,
+        UFixed minTvlRatioTrigger
+    ) external;
 
+    /// @dev Set the stake locking period for protocol stakes to the specified duration.
+    function setProtocolLockingPeriod(Seconds lockingPeriod) external;
 
-    // target management
+    /// @dev Set the protocol reward rate.
+    function setProtocolRewardRate(UFixed rewardRate) external;
+
+    /// @dev Set the staking rate for the specified chain and token.
+    /// The staking rate defines the amount of staked dips required to back up 1 token of total value locked.
+    function setStakingRate(ChainId chainId, address token, UFixed stakingRate) external;
+
+    /// @dev Sets/updates the staking service contract to the staking service of the specified release.
+    function setStakingService(VersionPart release) external;
+
+    /// @dev Sets/updates the staking reader contract. 
+    function setStakingReader(address stakingReader) external;
+
+    /// @dev Registers a token for recording staking rate and total value locked.
+    function addToken(ChainId chainId, address token) external;
+
+    /// @dev Set the approval to the token handler.
+    /// Defines the max allowance from the staking wallet to the token handler.
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external;
+
+    //--- only target owner functions ---------------------------------------//
+
+    /// @dev (Re)fills the staking reward reserves for the specified target
+    /// Unpermissioned: anybody may fill up staking reward reserves
+    function refillRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+
+    /// @dev Defunds the staking reward reserves for the specified target
+    /// Permissioned: only the owner may call this function
+    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+
+    //--- target management -------------------------------------------------//
 
+    /// @dev Register a new target for staking.
+    /// Permissioned: only the staking service may call this function 
     function registerTarget(
         NftId targetNftId,
         ObjectType expectedObjectType,
-        uint256 chainId,
         Seconds initialLockingPeriod,
         UFixed initialRewardRate
     ) external;
 
 
-    /// @dev set the stake locking period to the specified duration.
-    /// permissioned: only the staking service may call this function
+    /// @dev Set the stake locking period to the specified duration.
+    /// Permissioned: only the staking service may call this function
     function setLockingPeriod(NftId targetNftId, Seconds lockingPeriod) external;
 
-    /// @dev update the target specific reward rate.
-    /// permissioned: only the staking service may call this function
+    /// @dev Update the target specific reward rate.
+    /// Permissioned: only the staking service may call this function
     function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
 
-    /// @dev (re)fills the staking reward reserves for the specified target
-    /// unpermissioned: anybody may fill up staking reward reserves
-    function refillRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+    /// @dev Set the staking limits for the specified target.
+    /// The margin amount allows staker to stake over the current required stakes by this amount.
+    /// The limit amount restricts stakers to ever stake more than this amount.
+    /// Permissioned: only the target owner may call this function
+    function setTargetLimits(NftId targetNftId, Amount marginAmount, Amount limitAmount) external;
 
-    /// @dev defunds the staking reward reserves for the specified target
-    /// permissioned: only the staking service may call this function
-    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+    // TODO refactor this into new setStakingLimits
+    /// @dev Set the maximum staked amount for the specified target.
+    /// Permissioned: only the staking service may call this function
+    function setMaxStakedAmount(NftId targetNftId, Amount stakeLimitAmount) external;
 
+    /// @dev Register a token for the specified target.
+    /// Used for instance targets. Each product may introduce its own token.
+    /// Permissioned: only the staking service may call this function
+    function addTargetToken(NftId targetNftId, address token) external;
 
-    /// @dev increases the total value locked amount for the specified target by the provided token amount.
+    /// @dev Increases the total value locked amount for the specified target by the provided token amount.
     /// function is called when a new policy is collateralized.
     /// function restricted to the pool service.
-    function increaseTotalValueLocked(NftId targetNftId, address token, Amount amount) external returns (Amount newBalance);
+    function increaseTotalValueLocked(NftId targetNftId, address token, Amount amount) external;
 
-
-    /// @dev decreases the total value locked amount for the specified target by the provided token amount.
+    /// @dev Decreases the total value locked amount for the specified target by the provided token amount.
     /// function is called when a new policy is closed or payouts are executed.
     /// function restricted to the pool service.
-    function decreaseTotalValueLocked(NftId targetNftId, address token, Amount amount) external returns (Amount newBalance);
+    function decreaseTotalValueLocked(NftId targetNftId, address token, Amount amount) external;
 
 
     function updateRemoteTvl(NftId targetNftId, address token, Amount amount) external;
 
-    // staking functions
+    //--- service interaction functions -------------------------------------//
 
-    /// @dev creat a new stake info object
-    /// permissioned: only staking service may call this function.
-    function createStake(NftId stakeNftId, NftId targetNftId, Amount dipAmount) external;
+    /// @dev Set the staking limits for the specified target.
+    /// Permissioned: only the staking service may call this function
+    // TODO implement
+    // function setStakingLimitsByService(NftId targetNftId, Amount marginAmount, Amount limitAmount) external;
 
-    /// @dev increase the staked dip by dipAmount for the specified stake.
-    /// staking rewards are updated and added to the staked dips as well.
-    /// the function returns the new total amount of staked dips.
-    function stake(NftId stakeNftId, Amount dipAmount) external returns (Amount stakeBalance);
+    /// @dev (Re)fills the staking reward reserves for the specified target
+    /// Unpermissioned: anybody may fill up staking reward reserves
+    function refillRewardReservesByService(NftId targetNftId, Amount dipAmount, address transferFrom) external returns (Amount newBalance);
 
-    /// @dev restakes the dips to a new target.
-    /// the sum of the staked dips and the accumulated rewards will be restaked.
+    /// @dev Defunds the staking reward reserves for the specified target
+    /// Permissioned: only the owner may call this function
+    function withdrawRewardReservesByService(NftId targetNftId, Amount dipAmount, address transferTo) external returns (Amount newBalance);
+
+    //--- public functions -----------------------------------------------------//
+
+    /// @dev Updates the current limit amount for the specified target.
+    /// The function takes into account the current TVL amount per token
+    /// and the current staking rate for the token to calculate the required stake amount.
+    /// Based on this required stake amount and the targets margin and hard limit (from LimitInfo) 
+    /// the function updates the target limit amount (in the target info)
+    function updateTargetLimit(NftId targetNftId) external;
+
+    /// @dev Creates a new stake to the specified target over the given DIP amount.
+    /// The stake owner is provided as an argument and becomes the stake NFT holder.
+    /// This function is permissionless and may be called by any user.
+    function createStake(NftId targetNftId, Amount dipAmount, address stakeOwner) external returns (NftId stakeNftId);
+
+    //--- stake owner functions -------------------------------------------------//
+
+    /// @dev Increase the staked DIP by dipAmount for the specified stake.
+    /// Staking rewards are updated and added to the staked DIP amount as well.
+    /// The function returns the new total amount of staked dips.
+    function stake(NftId stakeNftId, Amount dipAmount) external returns (Amount newStakeBalance);
+
+    /// @dev Pays the specified DIP amount to the holder of the stake NFT ID.
     /// permissioned: only staking service may call this function.
-    function restake(NftId stakeNftId, NftId newTargetNftId) external returns (NftId newStakeNftId);
+    function unstake(NftId stakeNftId) external returns (Amount unstakedAmount);
 
-    /// @dev retuns the specified amount of dips to the holder of the specified stake nft.
-    /// if dipAmount is set to Amount.max() all staked dips and all rewards are transferred to 
+    /// @dev restakes the dips to a new target.
+    /// the sum of the staked dips and the accumulated rewards will be restaked.
     /// permissioned: only staking service may call this function.
-    function unstake(NftId stakeNftId)
-        external
-        returns (
-            Amount unstakedAmount,
-            Amount rewardsClaimedAmount
-        );
+    function restake(NftId stakeNftId, NftId newTargetNftId) external returns (NftId newStakeNftId, Amount newStakeBalance);
 
     /// @dev update stake rewards for current time.
     /// may be called before an announement of a decrease of a reward rate reduction.
     /// calling this functions ensures that reward balance is updated using the current (higher) reward rate.
     /// unpermissioned.
-    function updateRewards(NftId stakeNftId) external;
+    function updateRewards(NftId stakeNftId) external returns (Amount newRewardAmount);
 
     /// @dev transfers all rewards accumulated so far to the holder of the specified stake nft.
     /// permissioned: only staking service may call this function.
-    function claimRewards(NftId stakeNftId)
-        external
-        returns (
-            Amount rewardsClaimedAmount
-        );
+    function claimRewards(NftId stakeNftId) external returns (Amount rewardsClaimedAmount);
 
     //--- view and pure functions -------------------------------------------//
 
+    function getTargetHandler() external view returns (TargetHandler targetHandler);
     function getStakingStore() external view returns (StakingStore stakingStore);
     function getStakingReader() external view returns (StakingReader reader);
 }

package/contracts/staking/IStakingService.sol

@@ -3,9 +3,10 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
-import {Amount} from "../type/Amount.sol";
 import {IService} from "../shared/IService.sol";
 import {IStaking} from "./IStaking.sol";
+
+import {Amount} from "../type/Amount.sol";
 import {NftId} from "../type/NftId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
@@ -23,9 +24,11 @@ interface IStakingService is IService
     event LogStakingServiceRewardReservesIncreased(NftId targetNftId, address rewardProvider, Amount dipAmount, Amount newBalance);
     event LogStakingServiceRewardReservesDecreased(NftId targetNftId, address targetOwner, Amount dipAmount, Amount newBalance);
 
+    event LogStakingServiceStakeObjectCreated(NftId stakeNftId, NftId targetNftId, address stakeOwner);
     event LogStakingServiceStakeCreated(NftId stakeNftId, NftId targetNftId, address owner, Amount stakedAmount);
     event LogStakingServiceStakeIncreased(NftId stakeNftId, address owner, Amount stakedAmount, Amount stakeBalance);
     event LogStakingServiceUnstaked(NftId stakeNftId, address stakeOwner, Amount totalAmount);
+    event LogStakingServiceStakeRestaked(address stakeOwner, NftId indexed stakeNftId, NftId newStakeNftId, NftId indexed newTargetNftId, Amount indexed newStakeBalance);
 
     event LogStakingServiceRewardsUpdated(NftId stakeNftId);
     event LogStakingServiceRewardsClaimed(NftId stakeNftId, address stakeOwner, Amount rewardsClaimedAmount);
@@ -36,28 +39,17 @@ interface IStakingService is IService
     error ErrorStakingServiceNotSupportingIStaking(address stakingAddress);
 
     // create
+    error ErrorStakingServiceTargetUnknown(NftId targetNftId);
     error ErrorStakingServiceZeroTargetNftId();
     error ErrorStakingServiceNotTargetNftId(NftId targetNftId);
     error ErrorStakingServiceNotActiveTargetNftId(NftId targetNftId);
     error ErrorStakingServiceDipBalanceInsufficient(NftId targetNftId, uint256 amount, uint256 balance);
     error ErrorStakingServiceDipAllowanceInsufficient(NftId targetNftId, address tokenHandler, uint256 amount, uint256 allowance);
 
-    /// @dev Set the protocol reward rate stake locking period to the specified duration.
-    /// Permissioned: only staking owner
-    // TODO implement
-    // function setProtocolRewardRate(UFixed rewardRate) external;
-    // function setProtocolLockingPeriod(Seconds lockingPeriod) external;
-    // TODO also make sure that protocol rewards can be refilled and withdrawn
-
-    /// @dev Approves the staking token handler.
-    /// Reverts if the staking token handler wallet is not the token handler itself.
-    function approveTokenHandler(
-        IERC20Metadata token,
-        Amount amount
-    ) external;
+    //--- functions for instance service -----------------------------------------------//
 
-    /// @dev creates/registers an on-chain instance staking target.
-    /// function granted to instance service
+    /// @dev Creates/registers an on-chain instance staking target.
+    /// Permissioned: Only instance service
     function createInstanceTarget(
         NftId targetNftId,
         Seconds initialLockingPeriod,
@@ -65,101 +57,71 @@ interface IStakingService is IService
     ) external;
 
     /// @dev Set the instance stake locking period to the specified duration.
-    /// Permissioned: Only owner of the specified target.
+    /// Permissioned: Only instance service
     function setInstanceLockingPeriod(NftId instanceNftId, Seconds lockingPeriod) external;
 
     /// @dev Set the instance reward rate to the specified value.
-    /// Permissioned: Only owner of the specified target.
+    /// Permissioned: Only instance service
     function setInstanceRewardRate(NftId instanceNftId, UFixed rewardRate) external;
 
+    /// @dev Set the instance max staked amount to the specified value.
+    /// Permissioned: Only instance service
+    function setInstanceMaxStakedAmount(NftId instanceNftId, Amount maxStakingAmount) external;
+
     /// @dev (Re)fills the staking reward reserves for the specified target using the dips provided by the reward provider.
-    /// unpermissioned: anybody may fill up staking reward reserves
+    /// Permissioned: Only instance service
     function refillInstanceRewardReserves(NftId instanceNftId, address rewardProvider, Amount dipAmount) external returns (Amount newBalance);
 
-    /// @dev (Re)fills the staking reward reserves for the specified target using the dips provided by the sender
-    /// unpermissioned: anybody may fill up staking reward reserves
-    function refillRewardReservesBySender(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
-
     /// @dev Defunds the staking reward reserves for the specified target
-    /// Permissioned: only the target owner may call this function
+    /// Permissioned: Only instance service
     function withdrawInstanceRewardReserves(NftId instanceNftId, Amount dipAmount) external returns (Amount newBalance);
 
-    /// @dev create a new stake with amount DIP to the specified target
-    /// returns the id of the newly minted stake nft
-    /// permissionless function
-    function create(
+    /// @dev Sets total value locked data for a target contract on a different chain.
+    /// this is done via CCIP (cross chain communication) 
+    function setTotalValueLocked(
         NftId targetNftId,
+        address token,
         Amount amount
-    )
-        external
-        returns (
-            NftId stakeNftId
-        );
-
-
-    /// @dev increase an existing stake by amount DIP
-    /// updates and restakes the staking reward amount
-    /// function restricted to the current stake owner
-    function stake(
-        NftId stakeNftId,
-        Amount amount
-    )
-        external;
-
-
-    /// @dev re-stakes the current staked DIP as well as all accumulated rewards to the new stake target.
-    /// all related stakes and all accumulated reward DIP are transferred to the current stake holder
-    /// function restricted to the current stake owner
-    function restakeToNewTarget(
-        NftId stakeNftId,
-        NftId newTargetNftId
-    )
-        external
-        returns (
-            NftId newStakeNftId
-        );
-
-
-    /// @dev updates the reward balance of the stake using the current reward rate.
-    function updateRewards(
-        NftId stakeNftId
-    )
-        external;
-
+    ) external;
 
-    /// @dev claims all available rewards.
-    function claimRewards(
-        NftId stakeNftId
-    )
-        external;
+    //--- functions for staking component ---------------------------------------------//
 
+    /// @dev Creates a new stake object for the specified target via the registry service.
+    /// Permissioned: only the staking component may call this function
+    function createStakeObject(
+        NftId targetNftId,
+        address initialOwner
+    ) external returns (NftId stakeNftId);
 
-    /// @dev unstakes all dips (stakes and rewards) of an existing stake.
-    /// function restricted to the current stake owner
-    function unstake(
-        NftId stakeNftId
-    )
-        external;
+    /// @dev Collect DIP token from stake owner.
+    /// Permissioned: only the staking component may call this function
+    function pullDipToken(Amount dipAmount, address stakeOwner) external;
 
+    /// @dev Transfer DIP token to stake owner.
+    /// Permissioned: only the staking component may call this function
+    function pushDipToken(Amount dipAmount, address stakeOwner) external;
 
-    /// @dev sets total value locked data for a target contract on a different chain.
-    /// this is done via CCIP (cross chain communication) 
-    function setTotalValueLocked(
-        NftId targetNftId,
-        address token,
+    /// @dev Approves the staking token handler.
+    /// Permissioned: only the staking component may call this function
+    function approveTokenHandler(
+        IERC20Metadata token,
         Amount amount
-    )
-        external;
+    ) external;
+
+    //--- view functions --------------------------------------------------------------//
 
     function getDipToken()
         external
+        view
         returns (IERC20Metadata dip);
 
     function getTokenHandler()
         external
+        view
         returns (TokenHandler tokenHandler);
 
     function getStaking()
         external
+        view
         returns (IStaking staking);
 }

package/contracts/staking/ITargetLimitHandler.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {NftId} from "../type/NftId.sol";
+
+interface ITargetLimitHandler {
+
+    /// @dev Returns true iff the target limit update is required.
+    function isLimitUpdateRequired(
+        NftId targetNftId, 
+        address token, 
+        uint16 tvlUpdatesCount,
+        Amount baselineTvlAmount, 
+        Amount currentTvlAmount
+    ) external view returns (bool updateIsRequired);
+}