@etherisc/gif-next 0.0.2-c4ddbb7-673 → 0.0.2-c5049d4-401

package/contracts/shared/ComponentServiceManager.sol

@@ -11,15 +11,18 @@ contract ComponentServiceManager is ProxyManager {
 
     /// @dev initializes proxy manager with service implementation 
     constructor(
-        address registryAddress
+        address authority, 
+        address registry,
+        bytes32 salt
     )
-        ProxyManager(registryAddress)
     {
         ComponentService svc = new ComponentService();
-        bytes memory data = abi.encode(registryAddress, address(this));
-        IVersionable versionable = deploy(
+        bytes memory data = abi.encode(registry, authority);
+        IVersionable versionable = initialize(
+            registry,
             address(svc), 
-            data);
+            data,
+            salt);
 
         _componentService = ComponentService(address(versionable));
     }

package/contracts/shared/ComponentVerifyingService.sol

@@ -32,7 +32,7 @@ abstract contract ComponentVerifyingService is
             IInstance instance
         )
     {
-        componentNftId = getRegistry().getNftId(msg.sender);
+        componentNftId = getRegistry().getNftIdForAddress(msg.sender);
         (componentInfo, instance) = _getAndVerifyComponentInfo(
             componentNftId, 
             expectedType,

package/contracts/shared/ContractLib.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
+import {IPolicyHolder} from "./IPolicyHolder.sol";
+
+library ContractLib {
+
+    function isPolicyHolder(address target) external view returns (bool) {
+        return ERC165Checker.supportsInterface(target, type(IPolicyHolder).interfaceId);
+    }
+
+    function isAccessManaged(address target) external view returns (bool) {
+        if (!isContract(target)) {
+            return false;
+        }
+
+        (bool success, ) = target.staticcall(
+            abi.encodeWithSelector(
+                IAccessManaged.authority.selector));
+
+        return success;
+    }
+
+    function isContract(address target) public view returns (bool) {
+        uint256 size;
+        assembly {
+            size := extcodesize(target)
+        }
+        return size > 0;
+    }
+
+    function supportsInterface(address target, bytes4 interfaceId)  external view returns (bool) {
+        return ERC165Checker.supportsInterface(target, interfaceId);
+    }
+}

package/contracts/shared/IComponent.sol

@@ -23,7 +23,6 @@ interface IComponent is
     error ErrorComponentNameLengthZero();
     error ErrorComponentWalletAddressZero();
     error ErrorComponentWalletAddressIsSameAsCurrent();
-    error ErrorComponentWalletAllowanceTooSmall(address oldWallet, address newWallet, uint256 allowance, uint256 balance);
     error ErrorComponentWalletNotComponent();
 
     event LogComponentWalletAddressChanged(address oldWallet, address newWallet);
@@ -35,10 +34,11 @@ interface IComponent is
     /// only component owner (nft holder) is authorizes to call this function
     function approveTokenHandler(Amount spendingLimitAmount) external;
 
-    /// @dev sets the wallet address for the component
-    /// if the current wallet has tokens, these will be transferred
+    /// @dev sets the wallet address for the component.
+    /// 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 for the component to move all tokens must exist
+    /// owner of the external wallet to the tokenhandler of the component that 
+    /// covers the current component balance must exist
     function setWallet(address walletAddress) external;
 
     /// @dev returns the name of this component

package/contracts/shared/IInstanceLinkedComponent.sol

@@ -7,21 +7,14 @@ import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IER
 import {Amount} from "../type/Amount.sol";
 import {IComponent} from "../shared/IComponent.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
-import {IComponents} from "../instance/module/IComponents.sol";
 import {IInstance} from "../instance/IInstance.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
-import {IProductService} from "../product/IProductService.sol";
-import {IRegisterable} from "../shared/IRegisterable.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType} from "../type/ObjectType.sol";
-import {TokenHandler} from "../shared/TokenHandler.sol";
 
 /// @dev component base class
 /// component examples are product, distribution, pool and oracle
 interface IInstanceLinkedComponent is 
     IComponent
 {
-    error ErrorComponentNotProductService(address caller);
     error ErrorComponentNotInstance(NftId instanceNftId);
     error ErrorComponentProductNftAlreadySet();
 
@@ -38,19 +31,19 @@ interface IInstanceLinkedComponent is
     /// only component owner (nft holder) is authorizes to call this function
     function unlock() external;
 
+    /// @dev Withdraw fees from the distribution component. Only component owner is allowed to withdraw fees.
+    /// @param amount the amount to withdraw
+    /// @return withdrawnAmount the amount that was actually withdrawn
+    function withdrawFees(Amount amount) external returns (Amount withdrawnAmount);
+
     /// @dev defines the instance to which this component is linked to
     function getInstance() external view returns (IInstance instance);
 
-    /// @dev defines the product to which this component is linked to
-    /// this is only relevant for pool and distribution components
-    function getProductNftId() external view returns (NftId productNftId);
-
     /// @dev returns the initial component authorization specification.
     function getAuthorization() external view returns (IAuthorization authorization);
 
-    /// @dev Withdraw fees from the distribution component. Only component owner is allowed to withdraw fees.
-    /// @param amount the amount to withdraw
-    /// @return withdrawnAmount the amount that was actually withdrawn
-    function withdrawFees(Amount amount) external returns (Amount withdrawnAmount);
+    /// @dev defines the product to which this component is linked to
+    /// this is only relevant for pool and distribution components
+    function getProductNftId() external view returns (NftId productNftId);
 
 }

package/contracts/shared/IPolicyHolder.sol

@@ -9,37 +9,27 @@ import {ClaimId} from "../type/ClaimId.sol";
 import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
 import {NftId} from "../type/NftId.sol";
 import {PayoutId} from "../type/PayoutId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
 
-/// @dev generic interface for contracts that need to hold policies and receive payouts
-/// GIF will notify policy holder contracts for policy creation and payout execution
+/// @dev Generic interface for contracts that need to hold policies and receive payouts.
+/// The framework notifies policy holder contracts for policy creation/expiry, claim confirmation and payout execution
 interface IPolicyHolder is
     IERC165,
     IERC721Receiver,
     IRegistryLinked
 {
 
-    /// @dev callback function that will be called after successful policy activation
-    /// active policies may open claims under the activated policy
-    function policyActivated(NftId policyNftId) external;
+    /// @dev Callback function that will be called after successful policy activation.
+    /// Active policies may open claims under the activated policy.
+    function policyActivated(NftId policyNftId, Timestamp activatedAt) external;
 
-    /// @dev callback function to indicate the specified policy has expired
-    /// expired policies may no longer open claims
-    /// it is optional for products to notifiy policy holder of expired claims
-    function policyExpired(NftId policyNftId) external;
+    /// @dev Callback function to indicate the specified policy has expired.
+    /// expired policies no longer accept new claims.
+    function policyExpired(NftId policyNftId, Timestamp expiredAt) external;
 
-    /// @dev request for a payout by the requesting policy
-    /// the contract implements its use case specific handling for such requests.
-    /// eg. creation of a pending payout, a corresponding claim against one of the policies held by the IPolicyHolder
-    function requestPayout(NftId requestingPolicyNftId, Amount requestedPayoutAmount) external;
-
-    /// @dev callback function to notify the confirmation of the specified claim
-    /// active policies may open claims under the activated policy
+    /// @dev Callback function to notify the confirmation of the specified claim.
     function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external;
 
-    /// @dev callback function that will be called after a successful payout
-    function payoutExecuted(NftId policyNftId, PayoutId payoutId, address beneficiary, Amount amount) external;
-
-    /// @dev determines policy and claim specific beneficiary address
-    /// returned address will override GIF default where the policy nft holder is treated as beneficiary
-    function getBeneficiary(NftId policyNftId, PayoutId payoutId) external view returns (address beneficiary);
+    /// @dev Callback function to notify the successful payout.
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary) external;
 }

package/contracts/shared/InitializableERC165.sol

@@ -11,13 +11,13 @@ contract InitializableERC165 is
     mapping(bytes4 => bool) private _isSupported;
 
     // @dev initializes with support for ERC165
-    function initializeERC165() public onlyInitializing() {
+    function _initializeERC165() internal onlyInitializing() {
         _isSupported[type(IERC165).interfaceId] = true;
     }
 
     // @dev register support for provided interfaceId
     // includes initialization for ERC165_ID if not yet done
-    function registerInterface(bytes4 interfaceId) public onlyInitializing() {
+    function _registerInterface(bytes4 interfaceId) internal onlyInitializing() {
         _isSupported[interfaceId] = true;
     }
 

package/contracts/shared/InstanceLinkedComponent.sol

@@ -103,7 +103,7 @@ abstract contract InstanceLinkedComponent is
             revert ErrorComponentNotInstance(instanceNftId);
         }
 
-        initializeComponent(
+        _initializeComponent(
             $._instance.authority(), 
             registry, 
             instanceNftId, 
@@ -120,8 +120,8 @@ abstract contract InstanceLinkedComponent is
         $._initialAuthorization = authorization;
         $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
 
-        registerInterface(type(IAccessManaged).interfaceId);
-        registerInterface(type(IInstanceLinkedComponent).interfaceId);
+        _registerInterface(type(IAccessManaged).interfaceId);
+        _registerInterface(type(IInstanceLinkedComponent).interfaceId);
     }
 
     /// @dev for instance linked components the wallet address stored in the instance store.
@@ -132,7 +132,7 @@ abstract contract InstanceLinkedComponent is
 
 
     function _getComponentInfo() internal virtual override view returns (IComponents.ComponentInfo memory info) {
-        NftId componentNftId = getRegistry().getNftId(address(this));
+        NftId componentNftId = getRegistry().getNftIdForAddress(address(this));
 
         // if registered, attempt to return component info via instance reader
         if (componentNftId.gtz()) {

package/contracts/shared/NftOwnable.sol

@@ -30,16 +30,16 @@ contract NftOwnable is
 
     /// @dev initialization for upgradable contracts
     // used in _initializeRegisterable
-    function initializeNftOwnable(
+    function _initializeNftOwnable(
         address initialOwner,
         address registryAddress
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeRegistryLinked(registryAddress);
-        initializeERC165();
+        _initializeRegistryLinked(registryAddress);
+        _initializeERC165();
 
         if(initialOwner == address(0)) {
             revert ErrorNftOwnableInitialOwnerZero();
@@ -93,7 +93,7 @@ contract NftOwnable is
             revert ErrorNftOwnableContractNotRegistered(nftOwnableAddress);
         }
 
-        $._nftId = getRegistry().getNftId(nftOwnableAddress);
+        $._nftId = getRegistry().getNftIdForAddress(nftOwnableAddress);
 
         return $._nftId;
     }

package/contracts/shared/PolicyHolder.sol

@@ -10,62 +10,37 @@ import {IPolicyHolder} from "./IPolicyHolder.sol";
 import {NftId} from "../type/NftId.sol";
 import {PayoutId, PayoutIdLib} from "../type/PayoutId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
+import {Timestamp} from "../type/Timestamp.sol";
 
 /// @dev template implementation for IPolicyHolder
 contract PolicyHolder is
     InitializableERC165,
-    RegistryLinked, // TODO need upgradeable version
+    RegistryLinked,
     IPolicyHolder
 {
-    // keccak256(abi.encode(uint256(keccak256("etherisc.storage.PolicyHolder")) - 1)) & ~bytes32(uint256(0xff));
-    // TODO fix address
-    bytes32 public constant POLICY_HOLDER_STORAGE_LOCATION_V1 = 0x07ebcf49758b6ed3af50fa146bec0abe157c0218fe65dc0874c286e9d5da4f00;
-
-    struct PolicyHolderStorage {
-        mapping(NftId policyId => mapping(PayoutId payoutId => address beneficiary)) _beneficiary;
-        address _beneficiaryDefault;
-    }
-
-    function initializePolicyHolder(
-        address registryAddress,
-        address beneficiaryDefault
+    function _initializePolicyHolder(
+        address registryAddress
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeRegistryLinked(registryAddress);
-
-        _getPolicyHolderStorage()._beneficiaryDefault = beneficiaryDefault;
-
-        registerInterface(type(IPolicyHolder).interfaceId);
+        _initializeRegistryLinked(registryAddress);
+        _initializeERC165();
+        _registerInterface(type(IPolicyHolder).interfaceId);
     }
 
     /// @dev empty default implementation
-    function requestPayout(NftId requestingPolicyNftId, Amount requestedPayoutAmount) external { }
-
-    /// @dev empty default implementation
-    function policyActivated(NftId policyNftId) external {}
+    function policyActivated(NftId policyNftId, Timestamp activatedAt) external virtual {}
 
     /// @dev empty default implementation
-    function policyExpired(NftId policyNftId) external {}
+    function policyExpired(NftId policyNftId, Timestamp expiredAt) external virtual {}
 
     /// @dev empty default implementation
-    function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external {}
+    function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external virtual {}
 
     /// @dev empty default implementation
-    function payoutExecuted(NftId policyNftId, PayoutId payoutId, address beneficiary, Amount amount) external {}
-
-    /// @dev returns payout specific beneficiary
-    /// when no such beneficiary is defined the policy specific beneficiary is returned
-    function getBeneficiary(NftId policyNftId, PayoutId payoutId) external virtual view returns (address beneficiary) {
-        beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][payoutId];
-
-        // fallback to claim independent beneficiary
-        if(beneficiary == address(0) && payoutId.gtz()) {
-            beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][PayoutIdLib.zero()];
-        }
-    }
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary) external virtual {}
 
     //--- IERC165 functions ---------------// 
     function onERC721Received(
@@ -80,20 +55,4 @@ contract PolicyHolder is
     {
         return IERC721Receiver.onERC721Received.selector;
     }
-
-    /// @dev sets policy specific beneficiary (used when no payout specific beneficiary is defined)
-    function _setBeneficiary(NftId policyNftId, address beneficiary) internal {
-        _setBeneficiary(policyNftId, PayoutIdLib.zero(), beneficiary);
-    }
-
-    /// @dev sets policy and claim specific beneficiary
-    function _setBeneficiary(NftId policyNftId, PayoutId payoutId, address beneficiary) internal {
-        _getPolicyHolderStorage()._beneficiary[policyNftId][payoutId] = beneficiary;
-    }
-
-    function _getPolicyHolderStorage() private pure returns (PolicyHolderStorage storage $) {
-        assembly {
-            $.slot := POLICY_HOLDER_STORAGE_LOCATION_V1
-        }
-    }
 }

package/contracts/shared/Registerable.sol

@@ -24,7 +24,7 @@ contract Registerable is
         bytes _data;
     }
 
-    function initializeRegisterable(
+    function _initializeRegisterable(
         address registryAddress,
         NftId parentNftId,
         ObjectType objectType,
@@ -32,11 +32,11 @@ contract Registerable is
         address initialOwner,
         bytes memory registryData // writeonly data that will saved in the object info record of the registry
     )
-        public
+        internal
         virtual
-        onlyInitializing
+        onlyInitializing()
     {
-        initializeNftOwnable(
+        _initializeNftOwnable(
             initialOwner,
             registryAddress);
 

package/contracts/shared/RegistryLinked.sol

@@ -10,14 +10,15 @@ contract RegistryLinked is
     IRegistryLinked
 {
 
+    // priorize simplicity and size over using standard upgradeability structs
     IRegistry private _registry;
 
     /// @dev initialization for upgradable contracts
     // used in _initializeRegisterable
-    function initializeRegistryLinked(
+    function _initializeRegistryLinked(
         address registryAddress
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {

package/contracts/shared/Service.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.20;
 
 import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IService} from "./IService.sol";
@@ -19,28 +20,23 @@ abstract contract Service is
     Registerable,
     Versionable,
     AccessManagedUpgradeable,
+    ReentrancyGuardUpgradeable,
     IService
 {
 
     uint8 private constant GIF_MAJOR_VERSION = 3;
 
 
-    function initializeService(
+    function _initializeService(
         address registry, 
         address authority, // real authority for registry service adress(0) for other services
         address initialOwner
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeRegisterable(
-            registry, 
-            IRegistry(registry).getNftId(), 
-            SERVICE(), 
-            false, // is interceptor
-            initialOwner, 
-            ""); // data
+        __ReentrancyGuard_init();
 
         // externally provided authority
         if(authority != address(0)) {
@@ -52,8 +48,17 @@ abstract contract Service is
             __AccessManaged_init(IAccessManaged(registryServiceAddress).authority());
         }
 
-        registerInterface(type(IAccessManaged).interfaceId);
-        registerInterface(type(IService).interfaceId);
+        _initializeRegisterable(
+            registry, 
+            IRegistry(registry).getNftId(), 
+            SERVICE(), 
+            false, // is interceptor
+            initialOwner, 
+            ""); // data
+
+
+        _registerInterface(type(IAccessManaged).interfaceId);
+        _registerInterface(type(IService).interfaceId);
     }
 
     function getDomain() external virtual pure returns(ObjectType serviceDomain) {

package/contracts/shared/TokenHandler.sol

@@ -1,6 +1,7 @@
 // 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";
 
@@ -9,50 +10,130 @@ import {Amount} from "../type/Amount.sol";
 /// @dev token specific transfer helper
 /// a default token contract is provided via contract constructor
 /// relies internally on oz SafeERC20.safeTransferFrom
-contract TokenHandler {
+contract TokenHandler is AccessManaged {
+    error ErrorTokenHandlerAmountIsZero();
+    error ErrorTokenHandlerBalanceTooLow(address token, address from, uint256 balance, uint256 expectedBalance);
+    error ErrorTokenHandlerAllowanceTooSmall(address token, address from, address spender, uint256 allowance, uint256 expectedAllowance);
+    error ErrorTokenHandlerRecipientWalletsMustBeDistinct(address to, address to2, address to3);
+    
+    event LogTokenHandlerTokenTransfer(address token, address from, address to, uint256 amountTransferred);
+
     IERC20Metadata private _token;
 
-    constructor(address token) {
+    constructor(address token, address initialAuthority) AccessManaged(initialAuthority) {
         _token = IERC20Metadata(token);
     }
 
-    /// @dev transfer amount default tokens 
-    function transfer(
+    /// @dev returns the default token defined for this TokenHandler
+    function getToken()
+        external
+        view 
+        returns (IERC20Metadata)
+    {
+        return _token;
+    }
+    
+    /// @dev collect tokens from outside of the gif and transfer them to one wallet within the scope of gif.
+    /// This method also checks balance and allowance and makes sure the amount is greater than zero.
+    function collectTokens(
         address from,
         address to,
         Amount amount
     )
         external
+        restricted()
     {
-        SafeERC20.safeTransferFrom(
-            _token, 
-            from, 
-            to, 
-            amount.toInt());
+        _transfer(from, to, amount, true);
     }
 
-    /// @dev transfer amount of the specified token
-    function safeTransferFrom(
-        address token,
+    /// @dev collect tokens from outside of the gif and transfer them to three distinct wallets within the scope of gif
+    /// This method also checks balance and allowance and makes sure the amount is greater than zero.
+    function collectTokensToThreeRecipients( 
+        address from,
+        address to,
+        Amount amount,
+        address to2,
+        Amount amount2,
+        address to3,
+        Amount amount3
+    )
+        external
+        restricted()
+    {
+        if (to == to2 || to == to3 || to2 == to3) {
+            revert ErrorTokenHandlerRecipientWalletsMustBeDistinct(to, to2, to3);
+        }
+
+        _checkPreconditions(from, amount + amount2 + amount3);
+
+        if (amount.gtz()) {
+            _transfer(from, to, amount, false);
+        }
+        if (amount2.gtz()) {
+            _transfer(from, to2, amount2, false);
+        }
+        if (amount3.gtz()) {
+            _transfer(from, to3, amount3, false);
+        }
+    }
+
+    /// @dev distribute tokens from a wallet within the scope of gif to an external address.
+    /// This method also checks balance and allowance and makes sure the amount is greater than zero.
+    function distributeTokens(
         address from,
         address to,
         Amount amount
     )
         external
+        restricted()
+    {
+        _transfer(from, to, amount, true);
+    }
+
+    function _transfer(
+        address from,
+        address to,
+        Amount amount,
+        bool checkPreconditions
+    )
+        internal
     {
+        if (checkPreconditions) {
+            // check amount > 0, balance >= amount and allowance >= amount
+            _checkPreconditions(from, amount);
+        }
+
+        // transfer the tokens
+        emit LogTokenHandlerTokenTransfer(address(_token), from, to, amount.toInt());
         SafeERC20.safeTransferFrom(
-            IERC20Metadata(token), 
+            _token, 
             from, 
             to, 
             amount.toInt());
     }
 
-    /// @dev returns the default token defined for this TokenHandler
-    function getToken()
-        external
-        view 
-        returns (IERC20Metadata)
+    function _checkPreconditions(
+        address from,
+        Amount amount
+    ) 
+        internal
+        view
     {
-        return _token;
+        // amount must be greater than zero
+        if (amount.eqz()) {
+            revert ErrorTokenHandlerAmountIsZero();
+        }
+
+        // balance must be >= amount
+        uint256 balance = _token.balanceOf(from);
+        if (balance < amount.toInt()) {
+            revert ErrorTokenHandlerBalanceTooLow(address(_token), from, balance, amount.toInt());
+        }
+
+        // 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());
+        }
     }
 }

package/contracts/shared/TokenHandlerDeployerLib.sol

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

package/contracts/staking/IStaking.sol

@@ -42,8 +42,9 @@ interface IStaking is
     error ErrorStakingTargetNftIdZero();
     error ErrorStakingTargetTypeNotSupported(NftId targetNftId, ObjectType objectType);
     error ErrorStakingTargetUnexpectedObjectType(NftId targetNftId, ObjectType expectedObjectType, ObjectType actualObjectType);
-    error ErrorStakingLockingPeriodZero(NftId targetNftId);
+    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);