@etherisc/gif-next 0.0.2-93de5de-423 → 0.0.2-941d319-710

package/contracts/shared/TokenHandler.sol

@@ -1,27 +1,342 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-contract TokenHandler {
-    IERC20Metadata private _token;
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {NftId} from "../type/NftId.sol";
+import {SERVICE} from "../type/ObjectType.sol";
 
-    constructor(address token) {
-        _token = IERC20Metadata(token);
+
+/// @dev Token specific transfer helper base contract.
+/// A default token contract is provided via contract constructor.
+/// Relies internally on OpenZeppelin SafeERC20.safeTransferFrom.
+/// This base contract simplifies writing tests.
+contract TokenHandlerBase {
+
+    // _setWallet
+    event LogTokenHandlerWalletAddressChanged(NftId componentNftId, address oldWallet, address newWallet);
+    event LogTokenHandlerWalletTokensTransferred(NftId componentNftId, address oldWallet, address newWallet, Amount amount);
+
+    // _approveTokenHandler
+    event LogTokenHandlerTokenApproved(NftId nftId, address tokenHandler, address token, Amount amount, bool isMaxAmount);
+
+    // _transfer
+    event LogTokenHandlerTokenTransfer(address token, address from, address to, Amount amount);
+
+    // constructor
+    error ErrorTokenHandlerNotRegistry(address registry);
+    error ErrorTokenHandlerComponentNotRegistered(address component);
+    error ErrorTokenHandlerTokenAddressZero();
+
+    // _setWallet
+    error ErrorTokenHandlerNewWalletAddressZero();
+    error ErrorTokenHandlerAddressIsSameAsCurrent();
+
+    // _approveTokenHandler
+    error ErrorTokenHandlerNotWallet(NftId nftId, address tokenHandler, address wallet);
+
+    // _checkPreconditions
+    error ErrorTokenHandlerBalanceTooLow(address token, address from, uint256 balance, uint256 expectedBalance);
+    error ErrorTokenHandlerAllowanceTooSmall(address token, address from, address spender, uint256 allowance, uint256 expectedAllowance);
+    error ErrorTokenHandlerAmountIsZero();
+
+    IRegistry public immutable REGISTRY;
+    IERC20Metadata public immutable TOKEN;
+    address public immutable COMPONENT;
+    NftId public immutable NFT_ID;
+
+    address internal _wallet;
+
+    constructor(
+        address registry,
+        address component,
+        address token
+    )
+    {
+        if (!ContractLib.isRegistry(registry)) {
+            revert ErrorTokenHandlerNotRegistry(registry);
+        }
+
+        if (token == address(0)) {
+            revert ErrorTokenHandlerTokenAddressZero();
+        }
+
+        REGISTRY = IRegistry(registry);
+        COMPONENT = component;
+        NFT_ID = REGISTRY.getNftIdForAddress(component);
+
+        if (NFT_ID.eqz()) {
+            revert ErrorTokenHandlerComponentNotRegistered(component);
+        }
+
+        TOKEN = IERC20Metadata(token);
+
+        // self approval of token handler to max amount
+        _approve(TOKEN, AmountLib.max());
+    }
+
+
+    /// @dev Checks the balance and allowance for the from address and amount.
+    /// When requiring amount > 0 set checkAmount to true.
+    function checkBalanceAndAllowance(
+        address from,
+        Amount amount,
+        bool checkAmount
+    )
+        external
+        view
+    {
+        _checkBalanceAndAllowance(from, amount, checkAmount);
+    }
+
+
+    /// @dev Returns the wallet linked to this TokenHandler.
+    function getWallet()
+        public
+        view 
+        returns (address wallet)
+    {
+        if (_wallet == address(0)) {
+            return address(this);
+        }
+
+        return _wallet;
+    }
+
+
+    /// @dev Approves token handler to spend up to the specified amount of tokens.
+    /// Sets spending limit to type(uint256).max for AmountLib.max().
+    /// Reverts if wallet is not token handler itself.
+    /// Sets approvel using SareERC20.forceApprove internally.
+    function _approve(
+        IERC20Metadata token, 
+        Amount amount
+    )
+        internal
+    {
+        // check that wallet is token handler contract itself
+        if(_wallet != address(0)) {
+            revert ErrorTokenHandlerNotWallet(NFT_ID, address(this), _wallet);
+        }
+
+        // update spending limit for AmountLib.max() to type(uint256).max
+        uint256 amountInt = amount.toInt();
+        bool isMaxAmount = false;
+        if (amount == AmountLib.max()) {
+            amountInt = type(uint256).max;
+            isMaxAmount = true;
+        }
+
+        emit LogTokenHandlerTokenApproved(NFT_ID, address(this), address(token), amount, isMaxAmount);
+
+        // execute approval
+        SafeERC20.forceApprove(
+            token, 
+            address(this), 
+            amountInt);
+    }
+
+
+    function _setWallet(address newWallet)
+        internal
+    {
+        address oldWallet = _wallet;
+        if (newWallet == oldWallet) {
+            revert ErrorTokenHandlerAddressIsSameAsCurrent();
+        }
+
+        // effects
+        address oldWalletForBalance = getWallet();
+        _wallet = newWallet;
+
+        emit LogTokenHandlerWalletAddressChanged(NFT_ID, oldWallet, newWallet);
+
+        // interactions
+        Amount balanceAmount = AmountLib.toAmount(
+            TOKEN.balanceOf(oldWalletForBalance));
+
+        if (balanceAmount.gtz()) {
+            // move tokens from old to new wallet 
+            emit LogTokenHandlerWalletTokensTransferred(NFT_ID, oldWallet, newWallet, balanceAmount);
+
+            if (oldWallet == address(0)) {
+                // transfer from the component requires an allowance
+                _transfer(address(this), newWallet, balanceAmount, true);
+            } else if (newWallet == address(0)) {
+                _transfer(oldWallet, address(this), balanceAmount, true);
+            } else {
+                _transfer(oldWallet, newWallet, balanceAmount, true);
+            }
+        }
+    }
+
+
+    function _pullToken(address from, Amount amount)
+        internal
+    {
+        _transfer(from, getWallet(), amount, true);
+    }
+
+
+    function _pushToken(address to, Amount amount)
+        internal
+    {
+        _transfer(getWallet(), to, amount, true);
     }
 
-    // TODO add logging
-    function transfer(
+
+    function _transfer(
         address from,
         address to,
-        uint256 amount // TODO add authz (only treasury/instance/product/pool/ service)
-    ) external {
-        SafeERC20.safeTransferFrom(_token, from, to, amount);
-        // _token.transferFrom(from, to, amount);
+        Amount amount,
+        bool checkPreconditions
+    )
+        internal
+    {
+        if (checkPreconditions) {
+            bool checkAmount = true;
+            _checkBalanceAndAllowance(from, amount, checkAmount);
+        }
+
+        // transfer the tokens
+        emit LogTokenHandlerTokenTransfer(address(TOKEN), from, to, amount);
+
+        SafeERC20.safeTransferFrom(
+            TOKEN, 
+            from, 
+            to, 
+            amount.toInt());
     }
 
-    function getToken() external view returns (IERC20Metadata) {
-        return _token;
+
+    function _checkBalanceAndAllowance(
+        address from,
+        Amount amount,
+        bool checkAmount
+    ) 
+        internal
+        view
+    {
+        // amount must be greater than zero
+        if (checkAmount && amount.eqz()) {
+            revert ErrorTokenHandlerAmountIsZero();
+        }
+
+        // allowance must be >= amount
+        uint256 allowance = TOKEN.allowance(from, address(this));
+        if (allowance < amount.toInt()) {
+            revert ErrorTokenHandlerAllowanceTooSmall(address(TOKEN), from, address(this), allowance, amount.toInt());
+        }
+
+        // balance must be >= amount
+        uint256 balance = TOKEN.balanceOf(from);
+        if (balance < amount.toInt()) {
+            revert ErrorTokenHandlerBalanceTooLow(address(TOKEN), from, balance, amount.toInt());
+        }
+    }
+}
+
+
+/// @dev Token specific transfer helper.
+/// Contract is derived from TokenHandlerBase and adds 
+/// authorization based on OpenZeppelin AccessManaged.
+contract TokenHandler is
+    AccessManaged,
+    TokenHandlerBase
+{
+
+    // onlyService
+    error ErrorTokenHandlerNotService(address service);
+
+    modifier onlyService() {
+        if (!REGISTRY.isObjectType(msg.sender, SERVICE())) {
+            revert ErrorTokenHandlerNotService(msg.sender);
+        }
+        _;
+    }
+
+    constructor(
+        address registry,
+        address component,
+        address token, 
+        address authority
+    )
+        TokenHandlerBase(registry, component, token)
+        AccessManaged(authority)
+    { }
+
+    /// @dev Sets the wallet address for the component.
+    /// Seeting the new wallet address to address(0) will set the wallet to the tokenHandler contract itself.
+    /// If the current wallet has tokens, these will be transferred.
+    /// If the new wallet address is externally owned, an approval from the 
+    /// owner of the external wallet to the tokenhandler of the component that 
+    /// covers the current component balance must exist.
+    function setWallet(address newWallet)
+        external
+        restricted()
+        onlyService()
+    {
+        _setWallet(newWallet);
+    }
+
+
+    /// @dev Approves token handler to spend up to the specified amount of tokens.
+    /// Sets spending limit to type(uint256).max for AmountLib.max().
+    /// Reverts if component wallet is not component itself.
+    /// Sets approvel using SareERC20.forceApprove internally.
+    function approve(
+        IERC20Metadata token, 
+        Amount amount
+    )
+        external
+        restricted()
+        onlyService()
+    {
+        _approve(token, amount);
+    }
+
+    /// @dev Collect tokens from outside of GIF and transfer them to the wallet.
+    /// This method also checks balance and allowance and makes sure the amount is greater than zero.
+    function pullToken(
+        address from,
+        Amount amount
+    )
+        external
+        restricted()
+        onlyService()
+    {
+        _pullToken(from, amount);
+    }
+
+
+    /// @dev Distribute tokens from a wallet within the scope of gif to some address.
+    function pushToken(
+        address to,
+        Amount amount
+    )
+        external
+        restricted()
+        onlyService()
+    {
+        _pushToken(to, amount);
+    }
+
+
+    /// @dev Distribute fee tokens from a wallet within the scope of gif to some address.
+    /// Separate push function for component service.
+    function pushFeeToken(
+        address to,
+        Amount amount
+    )
+        external
+        restricted()
+        onlyService()
+    {
+        _pushToken(to, amount);
     }
 }

package/contracts/shared/TokenHandlerDeployerLib.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {TokenHandler} from "./TokenHandler.sol";
+
+library TokenHandlerDeployerLib {
+
+    function deployTokenHandler(
+        address registry,
+        address component,
+        address token, 
+        address authority
+    )
+        public 
+        returns (TokenHandler)
+    {
+        return new TokenHandler(registry, component, token, authority);
+    }
+
+}

package/contracts/staking/IStaking.sol

@@ -0,0 +1,264 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+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 {Timestamp} from "../type/Timestamp.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {VersionPart} from "../type/Version.sol";
+
+
+interface IStaking is 
+    IComponent,
+    IVersionable
+{
+
+    // owner functions
+    event LogStakingProtocolLockingPeriodSet(NftId targetNftId, Seconds newLockingPeriod, Seconds oldLockingPeriod, Blocknumber lastUpdatedIn);
+    event LogStakingProtocolRewardRateSet(NftId targetNftId, UFixed newRewardRate, UFixed oldRewardRate, Blocknumber lastUpdatedIn);
+    event LogStakingStakingRateSet(ChainId chainId, address token, UFixed newStakingRate, UFixed oldStakingRate, Blocknumber lastUpdatedIn);
+    event LogStakingStakingServiceSet(address stakingService, VersionPart release, address oldStakingService);
+    event LogStakingStakingReaderSet(address stakingReader, address oldStakingReader);
+    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 LogStakingTotalValueLockedIncreased(NftId targetNftId, address token, Amount amount, Amount newBalance);
+    event LogStakingTotalValueLockedDecreased(NftId targetNftId, address token, Amount amount, Amount newBalance);
+
+    // targets
+    event LogStakingTargetCreated(NftId targetNftId, ObjectType objectType, Seconds lockingPeriod, UFixed rewardRate, Amount maxStakedAmount);
+
+    // target parameters
+    event LogStakingTargetLockingPeriodSet(NftId targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod);
+    event LogStakingTargetRewardRateSet(NftId targetNftId, UFixed rewardRate, UFixed oldRewardRate);
+    event LogStakingTargetMaxStakedAmountSet(NftId targetNftId, Amount maxStakedAmount);
+
+    // 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);
+    event LogStakingRewardsRestaked(NftId stakeNftId, Amount restakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil);
+    event LogStakingStaked(NftId stakeNftId, Amount stakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil);
+    event LogStakingUnstaked(NftId stakeNftId, Amount unstakedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil);
+    event LogStakingRewardsClaimed(NftId stakeNftId, Amount claimedAmount, Amount stakeBalance, Amount rewardBalance, Timestamp lockedUntil);
+
+    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(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);
+    error ErrorStakingTargetAlreadyRegistered(NftId targetNftId);
+    error ErrorStakingTargetNftIdZero();
+    error ErrorStakingTargetTypeNotSupported(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, ChainId chainId, address token);
+    error ErrorStakingTargetMaxStakedAmountExceeded(NftId targetNftId, Amount maxStakedAmount, Amount stakedAmount);
+
+    error ErrorStakingStakeAmountZero(NftId targetNftId);
+
+    // info for individual stake
+    struct StakeInfo {
+        // 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 TargetInfo {
+        // Slot 0
+        Amount stakedAmount; // 96
+        Amount rewardAmount; // 96
+        Blocknumber lastUpdateIn; // 40, needed for traceability
+        // Slot 1
+        Amount reserveAmount; // 96
+        Amount maxStakedAmount; // 96
+        Seconds lockingPeriod; // 40
+        ObjectType objectType; // 8
+        // Slot 2
+        UFixed rewardRate; // 160
+        ChainId chainId; // 96 redundant to target nft id
+    }
+
+    struct TvlInfo {
+        // Slot 0
+        Amount tvlAmount; // 96
+        Blocknumber lastUpdateIn; // 40, needed for traceability
+    }
+
+    struct TokenInfo {
+        // Slot 0
+        UFixed stakingRate; // 160
+        Blocknumber lastUpdateIn; // 40, needed for traceability
+    }
+
+    function initializeTokenHandler() external;
+
+    //--- only owner functions -------------------------------------------//
+
+    /// @dev Set the stake locking period for protocol stakes to the specified duration.
+    function setProtocolLockingPeriod(Seconds lockingPeriod) external;
+
+    /// @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(StakingReader 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,
+        Seconds initialLockingPeriod,
+        UFixed initialRewardRate
+    ) external;
+
+
+    /// @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
+    function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
+
+    /// @dev Set the maximum staked amount for the specified target.
+    /// Permissioned: only the staking service may call this function
+    function setMaxStakedAmount(NftId targetNftId, Amount maxStakedAmount) external;
+
+    /// @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 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);
+
+    /// @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.
+    /// 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);
+
+    /// @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 updateRemoteTvl(NftId targetNftId, address token, Amount amount) external;
+
+    // staking functions
+
+    /// @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);
+
+    /// @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 unstake(NftId stakeNftId) external returns (Amount unstakedAmount);
+
+    /// @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 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 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);
+
+    //--- view and pure functions -------------------------------------------//
+
+    function getStakingStore() external view returns (StakingStore stakingStore);
+    function getStakingReader() external view returns (StakingReader reader);
+}