@etherisc/gif-next 0.0.2-ebf1a6b-485 → 0.0.2-ec4918f-024

package/contracts/shared/PolicyHolder.sol

@@ -1,55 +1,50 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
-import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
-import {ERC165} from "./ERC165.sol";
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {InitializableERC165} from "./InitializableERC165.sol";
 import {IPolicyHolder} from "./IPolicyHolder.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId} from "../types/NftId.sol";
-import {NumberId} from "../types/NumberId.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
-    ERC165,
+    InitializableERC165,
     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;
+    // TODO add modifier to protect callback functions from unauthorized access
+    // callbacks must only be allowed from the policy and claim services
+    // will need a release parameter to fetch the right service addresses for the modifiers
 
-    // TODO uncomment/fix/refactor
-    struct PolicyHolderStorage {
-        // mapping(NftId policyId => mapping(NumberId claimId => address beneficiary)) private _claimBeneficiary;
-        // mapping(NftId policyId => address beneficiary) private _beneficiary;
-        bool dummy;
-    }
-
-    function initializePolicyHolder(
+    function _initializePolicyHolder(
         address registryAddress
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeRegistryLinked(registryAddress);
+        _initializeRegistryLinked(registryAddress);
+        _initializeERC165();
+        _registerInterface(type(IPolicyHolder).interfaceId);
     }
 
     /// @dev empty default implementation
-    function policyCreatedCallback(NftId policyNftId) external virtual { }
+    function policyActivated(NftId policyNftId, Timestamp activatedAt) external virtual {}
 
     /// @dev empty default implementation
-    function payoutExecutedCallback(NftId policyNftId, NumberId payoutId, address beneficiary, uint256 amount) external virtual { }
+    function policyExpired(NftId policyNftId, Timestamp expiredAt) external virtual {}
 
-    /// @dev determines beneficiary address that will be used in payouts targeting this contract
-    /// returned address will override GIF default where the policy nft holder is treated as beneficiary
-    function getBeneficiary(NftId policyId, NumberId claimId) external virtual view returns (address beneficiary) { 
-        // TODO add implementation
-    }
+    /// @dev empty default implementation
+    function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external virtual {}
+
+    /// @dev empty default implementation
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary) external virtual {}
 
     //--- IERC165 functions ---------------// 
     function onERC721Received(
@@ -64,18 +59,4 @@ contract PolicyHolder is
     {
         return IERC721Receiver.onERC721Received.selector;
     }
-
-    function _setBeneficiary(address beneficiary) internal {
-
-    }
-
-    function _setBeneficiary(NftId policyId, address beneficiary) internal {
-
-    }
-
-    function _getPolicyHolderStorage() private pure returns (PolicyHolderStorage storage $) {
-        assembly {
-            $.slot := POLICY_HOLDER_STORAGE_LOCATION_V1
-        }
-    }
 }

package/contracts/shared/Registerable.sol

@@ -3,18 +3,20 @@ pragma solidity ^0.8.20;
 
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
-import {NftId, zeroNftId} from "../types/NftId.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
 import {NftOwnable} from "../shared/NftOwnable.sol";
-import {ObjectType} from "../types/ObjectType.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {VersionPart, VersionPartLib} from "../type/Version.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegisterable} from "./IRegisterable.sol";
-import {Versionable} from "./Versionable.sol";
 
 contract Registerable is
     NftOwnable,
     IRegisterable
 {
+    uint256 public constant GIF_RELEASE = 3;
+
     // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.shared.Registerable.sol")) - 1)) & ~bytes32(uint256(0xff));
     bytes32 public constant REGISTERABLE_LOCATION_V1 = 0x6548007c3f4340f82f348c576c0ff69f4f529cadd5ad41f96aae61abceeaa300;
 
@@ -25,45 +27,54 @@ contract Registerable is
         bytes _data;
     }
 
-    function _getRegisterableStorage() private pure returns (RegisterableStorage storage $) {
-        assembly {
-            $.slot := REGISTERABLE_LOCATION_V1
-        }
-    }
-
-    function initializeRegisterable(
-        address registryAddress,
+    function _initializeRegisterable(
+        address registry,
         NftId parentNftId,
         ObjectType objectType,
         bool isInterceptor,
         address initialOwner,
-        bytes memory registryData // writeonly data that will saved in the object info record of the registry
+        bytes memory data // writeonly data that will saved in the object info record of the registry
     )
-        public
+        internal
         virtual
-        onlyInitializing
+        onlyInitializing()
     {
-        initializeNftOwnable(
-            initialOwner,
-            registryAddress);
+        _initializeNftOwnable(
+            registry,
+            initialOwner);
+
+        RegisterableStorage storage $;
+        assembly {
+            $.slot := REGISTERABLE_LOCATION_V1
+        }
 
-        RegisterableStorage storage $ = _getRegisterableStorage();
         $._parentNftId = parentNftId;
         $._objectType = objectType;
         $._isInterceptor = isInterceptor;
-        $._data = registryData;
+        $._data = data;
+    }
+
+
+    /// @inheritdoc IRegisterable
+    function getRelease() public virtual pure returns (VersionPart release) {
+        return VersionPartLib.toVersionPart(GIF_RELEASE);
     }
 
 
+    /// @inheritdoc IRegisterable
     function getInitialInfo() 
         public 
         view 
         virtual 
         returns (IRegistry.ObjectInfo memory info) 
     {
-        RegisterableStorage memory $ = _getRegisterableStorage();
+        RegisterableStorage storage $;
+        assembly {
+            $.slot := REGISTERABLE_LOCATION_V1
+        }
+
         info = IRegistry.ObjectInfo(
-            zeroNftId(),
+            NftIdLib.zero(),
             $._parentNftId,
             $._objectType,
             $._isInterceptor,

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()
     {
@@ -40,9 +41,4 @@ contract RegistryLinked is
     function getRegistry() public view returns (IRegistry) {
         return _registry;
     }
-
-
-    function getRegistryAddress() public view returns (address) {
-        return address(_registry);
-    }
 }

package/contracts/shared/Service.sol

@@ -1,51 +1,51 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {ObjectType, SERVICE} from "../types/ObjectType.sol";
-import {NftId, zeroNftId} from "../types/NftId.sol";
-import {Version, VersionPart, VersionLib, VersionPartLib} from "../types/Version.sol";
+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 {Versionable} from "./Versionable.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
 import {IService} from "./IService.sol";
-import {IVersionable} from "./IVersionable.sol";
-import {Versionable} from "./Versionable.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ObjectType, REGISTRY, SERVICE} from "../type/ObjectType.sol";
 import {Registerable} from "./Registerable.sol";
-
-import {IRegistry} from "../registry/IRegistry.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
+import {Version, VersionLib, VersionPartLib} from "../type/Version.sol";
+import {Versionable} from "../upgradeability/Versionable.sol";
 
 
 /// @dev service base contract
 abstract contract Service is 
     Registerable,
     Versionable,
+    AccessManagedUpgradeable,
+    ReentrancyGuardUpgradeable,
     IService
 {
-    function getDomain() public pure virtual override returns(ObjectType);
-
-    // version major version MUST be consistent with major version of getVersion()
-    function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
-        return VersionPartLib.toVersionPart(3); 
-    }
-
-    // from Versionable
-    function getVersion()
-        public 
-        pure 
-        virtual override (IVersionable, Versionable)
-        returns(Version)
-    {
-        return VersionLib.toVersion(3,0,0);
-    }
 
-    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(
+        __ReentrancyGuard_init();
+
+        // externally provided authority
+        if(authority != address(0)) {
+            __AccessManaged_init(authority);
+        } else {
+            address registryServiceAddress = _getServiceAddress(REGISTRY());
+
+            // copy authority from already registered registry services
+            __AccessManaged_init(IAccessManaged(registryServiceAddress).authority());
+        }
+
+        _initializeRegisterable(
             registry, 
             IRegistry(registry).getNftId(), 
             SERVICE(), 
@@ -53,6 +53,32 @@ abstract contract Service is
             initialOwner, 
             ""); // data
 
-        registerInterface(type(IService).interfaceId);
+
+        _registerInterface(type(IAccessManaged).interfaceId);
+        _registerInterface(type(IService).interfaceId);
+    }
+
+    function getDomain() external virtual pure returns(ObjectType serviceDomain) {
+        return _getDomain();
+    }
+
+    function getRoleId() external virtual pure returns(RoleId serviceRoleId) {
+        return RoleIdLib.roleForTypeAndVersion(_getDomain(), getRelease());
+    }
+
+    /// @inheritdoc IVersionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(GIF_RELEASE,0,0);
+    }
+
+    function _getDomain() internal virtual pure returns (ObjectType);
+
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getRelease());
     }
 }

package/contracts/shared/TokenHandler.sol

@@ -1,27 +1,139 @@
 // 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 {
+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 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);
     }
 
-    // TODO add logging
-    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,
-        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
+    )
+        external
+        restricted()
+    {
+        _transfer(from, to, amount, true);
     }
 
-    function getToken() external view returns (IERC20Metadata) {
-        return _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(
+            _token, 
+            from, 
+            to, 
+            amount.toInt());
+    }
+
+    function _checkPreconditions(
+        address from,
+        Amount amount
+    ) 
+        internal
+        view
+    {
+        // 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

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {IComponent} from "../shared/IComponent.sol";
+import {IVersionable} from "../upgradeability/IVersionable.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";
+
+interface IStaking is 
+    IComponent,
+    IVersionable
+{
+    // staking rate
+    event LogStakingStakingRateSet(uint256 chainId, address token, UFixed oldStakingRate, UFixed newStakingRate);
+
+    // target parameters
+    event LogStakingLockingPeriodSet(NftId targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod);
+    event LogStakingRewardRateSet(NftId targetNftId, UFixed oldRewardRate, UFixed rewardRate);
+
+    // modifiers
+    error ErrorStakingNotStake(NftId stakeNftId);
+    error ErrorStakingNotTarget(NftId targetNftId);
+
+    error ErrorStakingNotStakingOwner();
+    error ErrorStakingNotNftOwner(NftId nftId);
+
+    // staking rate
+    error ErrorStakingTokenNotRegistered(uint256 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, uint256 chainId, address token);
+
+    error ErrorStakingTargetNotActive(NftId targetNftId);
+    error ErrorStakingStakeAmountZero(NftId targetNftId);
+
+    // info for individual stake
+    struct StakeInfo {
+        Timestamp lockedUntil;
+    }
+
+    struct TargetInfo {
+        ObjectType objectType;
+        uint256 chainId;
+        Seconds lockingPeriod;
+        UFixed rewardRate;
+    }
+
+    // staking rate management 
+
+    /// @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;
+
+
+    // target management
+
+    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
+    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 (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 staking service may call this function
+    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount) external returns (Amount newBalance);
+
+
+    /// @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 creat a new stake info object
+    /// permissioned: only staking service may call this function.
+    function createStake(NftId stakeNftId, NftId targetNftId, Amount dipAmount) 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 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);
+
+    /// @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 
+    /// permissioned: only staking service may call this function.
+    function unstake(NftId stakeNftId)
+        external
+        returns (
+            Amount unstakedAmount,
+            Amount rewardsClaimedAmount
+        );
+
+    /// @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;
+
+    /// @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
+        );
+
+    //--- helper functions --------------------------------------------------//
+
+    /// @dev transfers the specified amount of dips from the from address to the staking wallet.
+    function collectDipAmount(address from, Amount dipAmount) external;
+
+    /// @dev transfers the specified amount of dips from the staking wallet to the to addess.
+    function transferDipAmount(address to, Amount dipAmount) external;
+
+    //--- view and pure functions -------------------------------------------//
+
+    function getStakingStore() external view returns (StakingStore stakingStore);
+    function getStakingReader() external view returns (StakingReader reader);
+}