@etherisc/gif-next 0.0.2-e769e2e-077 → 0.0.2-e802d97-477

package/contracts/shared/KeyValueStore.sol

@@ -18,7 +18,7 @@ contract KeyValueStore is
 
     mapping(Key32 key32 => Value value) private _value;
 
-    function create(
+    function _create(
         Key32 key32, 
         bytes memory data
     )
@@ -34,14 +34,12 @@ contract KeyValueStore is
             revert ErrorKeyValueStoreAlreadyCreated(key32, objectType);
         }
 
-        address createdBy = msg.sender;
         Blocknumber blocknumber = blockBlocknumber();
         StateId initialState = hasLifecycle(objectType) ? getInitialState(objectType) : ACTIVE();
 
         // set metadata
         metadata.objectType = objectType;
         metadata.state = initialState;
-        metadata.updatedBy = createdBy;
         metadata.updatedIn = blocknumber;
         metadata.createdIn = blocknumber;
 
@@ -49,74 +47,34 @@ contract KeyValueStore is
         _value[key32].data = data;
 
         // solhint-disable-next-line avoid-tx-origin
-        emit LogInfoCreated(key32.toObjectType(), key32.toKeyId(), initialState, createdBy, tx.origin);
+        emit LogInfoCreated(key32.toObjectType(), key32.toKeyId(), initialState, msg.sender, tx.origin);
     }
 
-    function update(
+
+    function _update(
         Key32 key32, 
         bytes memory data,
         StateId state
     ) 
         internal
     {
-        if (state.eqz()) {
-            revert ErrorKeyValueStoreStateZero(key32);
-        }
-
-        Metadata storage metadata = _value[key32].metadata;
-        StateId stateOld = metadata.state;
-        if (stateOld.eqz()) {
-            revert ErrorKeyValueStoreNotExisting(key32);
-        }
-
-        // update data
-        _value[key32].data = data;
-
-        // update state 
-        if(state != KEEP_STATE()) {
-            checkTransition(metadata.objectType, stateOld, state);
-            metadata.state = state;
-        }
-
-        // update reest of metadata
-        address updatedBy = msg.sender;
-        Blocknumber lastUpdatedIn = metadata.updatedIn;
-
-        metadata.updatedBy = updatedBy;
-        metadata.updatedIn = blockBlocknumber();
-
-        // create log entries
-        // solhint-disable avoid-tx-origin
-        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, updatedBy, tx.origin, lastUpdatedIn);
-        emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, updatedBy, tx.origin, lastUpdatedIn);
-        // solhing-enable
-    }
-
-    function updateData(Key32 key32, bytes memory data) 
-        internal
-    {
-        Metadata storage metadata = _value[key32].metadata;
-        StateId state = metadata.state;
-        if (state.eqz()) {
-            revert ErrorKeyValueStoreNotExisting(key32);
-        }
+        // update state
+        Blocknumber lastUpdatedIn = _updateState(key32, state);
 
         // update data
         _value[key32].data = data;
 
-        // update metadata
-        address updatedBy = msg.sender;
-        Blocknumber lastUpdatedIn = metadata.updatedIn;
-        metadata.updatedBy = updatedBy;
-        metadata.updatedIn = blockBlocknumber();
-
-        // create log entry
         // solhint-disable-next-line avoid-tx-origin
-        emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, updatedBy, tx.origin, lastUpdatedIn);
+        emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, msg.sender, tx.origin, lastUpdatedIn);
     }
 
-    function updateState(Key32 key32, StateId state)
+
+    function _updateState(
+        Key32 key32, 
+        StateId state
+    )
         internal
+        returns (Blocknumber lastUpdatedIn)
     {
         if (state.eqz()) {
             revert ErrorKeyValueStoreStateZero(key32);
@@ -124,23 +82,23 @@ contract KeyValueStore is
 
         Metadata storage metadata = _value[key32].metadata;
         StateId stateOld = metadata.state;
+        lastUpdatedIn = metadata.updatedIn;
+
         if (stateOld.eqz()) {
             revert ErrorKeyValueStoreNotExisting(key32);
         }
 
-        // ensure state transistion is valid
-        checkTransition(metadata.objectType, stateOld, state);
+        // update state 
+        if(state != KEEP_STATE()) {
+            checkTransition(metadata.objectType, stateOld, state);
+            metadata.state = state;
+
+            // solhint-disable-next-line avoid-tx-origin
+            emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, msg.sender, tx.origin, lastUpdatedIn);
+        }
 
-        // update metadata (and state)
-        address updatedBy = msg.sender;
-        Blocknumber lastUpdatedIn = metadata.updatedIn;
-        metadata.state = state;
-        metadata.updatedBy = updatedBy;
+        // update metadata
         metadata.updatedIn = blockBlocknumber();
-
-        // create log entry
-        // solhint-disable-next-line avoid-tx-origin
-        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, updatedBy, tx.origin, lastUpdatedIn);
     }
 
     function exists(Key32 key32) public view returns (bool) {

package/contracts/shared/Lifecycle.sol

@@ -4,8 +4,8 @@ pragma solidity ^0.8.20;
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK, CLAIM, PAYOUT} from "../type/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID} from "../type/StateId.sol";
+import {ObjectType, COMPONENT, BUNDLE, POLICY, REQUEST, RISK, CLAIM, PAYOUT} from "../type/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID, FULFILLED, FAILED, CANCELLED} from "../type/StateId.sol";
 import {ILifecycle} from "./ILifecycle.sol";
 
 contract Lifecycle is
@@ -27,6 +27,7 @@ contract Lifecycle is
         _setupPolicyLifecycle();
         _setupClaimAndPayoutLifecycle();
         _setupRiskLifecycle();
+        _setupRequestLifecycle();
     }
 
     function hasLifecycle(
@@ -118,4 +119,12 @@ contract Lifecycle is
         _isValidTransition[RISK()][PAUSED()][ACTIVE()] = true;
         _isValidTransition[RISK()][PAUSED()][ARCHIVED()] = true;
     }
+
+    function _setupRequestLifecycle() internal {
+        _initialState[REQUEST()] = ACTIVE();
+        _isValidTransition[REQUEST()][ACTIVE()][FULFILLED()] = true;
+        _isValidTransition[REQUEST()][ACTIVE()][FAILED()] = true;
+        _isValidTransition[REQUEST()][FAILED()][FULFILLED()] = true;
+        _isValidTransition[REQUEST()][ACTIVE()][CANCELLED()] = true;
+    }
 }

package/contracts/shared/NftIdSetManager.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {LibNftIdSet} from "../type/NftIdSet.sol";
+import {NftId} from "../type/NftId.sol";
+
+contract NftIdSetManager {
+
+    error ErrorNftIdSetManagerNotOwner(address owner, address sender);
+    error ErrorNftIdSetManagerOwnerAlreadySet(address owner);
+    error ErrorNftIdSetManagerNftIdInvalid(NftId objectNftId);
+    error ErrorNftIdSetManagerAlreadyAdded(NftId objectNftId);
+
+    LibNftIdSet.Set private _allObjects;
+    LibNftIdSet.Set private _activeObjects;
+    address private _owner;
+
+    modifier onlyOwner() {
+        if(msg.sender != _owner) {
+            revert ErrorNftIdSetManagerNotOwner(_owner, msg.sender);
+        }
+        _;
+    }
+
+    constructor() {
+        _owner = msg.sender;
+    }
+
+    function add(NftId objectNftId) external onlyOwner {
+        LibNftIdSet.add(_allObjects, objectNftId);
+        LibNftIdSet.add(_activeObjects, objectNftId);
+    }
+
+    function activate(NftId componentNftId, NftId objectNftId) external onlyOwner {
+        LibNftIdSet.add(_activeObjects, objectNftId);
+    }
+
+    function deactivate(NftId componentNftId, NftId objectNftId) external onlyOwner {
+        LibNftIdSet.remove(_activeObjects, objectNftId);
+    }
+
+    function nftIds() external view returns (uint256 ids) {
+        return LibNftIdSet.size(_allObjects);
+    }
+
+    function getNftId(uint256 idx) external view returns (NftId) {
+        return LibNftIdSet.getElementAt(_allObjects, idx);
+    }
+
+    function exists(NftId objectNftId) external view returns (bool) {
+        return LibNftIdSet.contains(_allObjects, objectNftId);
+    }
+
+    function activeNftIds() external view returns (uint256 ids) {
+        return LibNftIdSet.size(_activeObjects);
+    }
+
+    function getActiveNftId(uint256 idx) external view returns (NftId) {
+        return LibNftIdSet.getElementAt(_activeObjects, idx);
+    }
+
+    function isActive(NftId objectNftId) external view returns (bool) {
+        return LibNftIdSet.contains(_activeObjects, objectNftId);
+    }
+}

package/contracts/shared/NftOwnable.sol

@@ -56,20 +56,9 @@ contract NftOwnable is
     function linkToRegisteredNftId()
         public
         virtual
+        returns (NftId nftId)
     {
-        NftOwnableStorage storage $ = _getNftOwnableStorage();
-
-        if ($._nftId.gtz()) {
-            revert ErrorNftOwnableAlreadyLinked($._nftId);
-        }
-
-        address contractAddress = address(this);
-
-        if (!getRegistry().isRegistered(contractAddress)) {
-            revert ErrorNftOwnableContractNotRegistered(contractAddress);
-        }
-
-        $._nftId = getRegistry().getNftId(contractAddress);
+        return _linkToNftOwnable(address(this));
     }
 
     function getNftId() public view virtual override returns (NftId) {

package/contracts/shared/PolicyHolder.sol

@@ -6,17 +6,18 @@ import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Recei
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
 import {Amount} from "../type/Amount.sol";
-import {ClaimId, ClaimIdLib} from "../type/ClaimId.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {ERC165} from "./ERC165.sol";
 import {IPolicyHolder} from "./IPolicyHolder.sol";
 import {NftId} from "../type/NftId.sol";
-import {PayoutId} from "../type/PayoutId.sol";
+import {PayoutId, PayoutIdLib} from "../type/PayoutId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
 
 /// @dev template implementation for IPolicyHolder
 contract PolicyHolder is
     ERC165,
-    RegistryLinked,
+    RegistryLinked, // TODO need upgradeable version
     IPolicyHolder
 {
     // keccak256(abi.encode(uint256(keccak256("etherisc.storage.PolicyHolder")) - 1)) & ~bytes32(uint256(0xff));
@@ -24,7 +25,8 @@ contract PolicyHolder is
     bytes32 public constant POLICY_HOLDER_STORAGE_LOCATION_V1 = 0x07ebcf49758b6ed3af50fa146bec0abe157c0218fe65dc0874c286e9d5da4f00;
 
     struct PolicyHolderStorage {
-        mapping(NftId policyId => mapping(ClaimId claimId => address beneficiary)) _beneficiary;
+        mapping(NftId policyId => mapping(PayoutId payoutId => address beneficiary)) _beneficiary;
+        address _beneficiaryDefault;
     }
 
     function initializePolicyHolder(
@@ -36,9 +38,15 @@ contract PolicyHolder is
         onlyInitializing()
     {
         initializeRegistryLinked(registryAddress);
+
+        _getPolicyHolderStorage()._beneficiaryDefault = beneficiaryDefault;
+
         registerInterface(type(IPolicyHolder).interfaceId);
     }
 
+    /// @dev empty default implementation
+    function requestPayout(NftId requestingPolicyNftId, Amount requestedPayoutAmount) external { }
+
     /// @dev empty default implementation
     function policyActivated(NftId policyNftId) external {}
 
@@ -51,14 +59,14 @@ contract PolicyHolder is
     /// @dev empty default implementation
     function payoutExecuted(NftId policyNftId, PayoutId payoutId, address beneficiary, Amount amount) external {}
 
-    /// @dev returns claim specific beneficiary
+    /// @dev returns payout specific beneficiary
     /// when no such beneficiary is defined the policy specific beneficiary is returned
-    function getBeneficiary(NftId policyNftId, ClaimId claimId) external virtual view returns (address beneficiary) {
-        beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][claimId];
+    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) && claimId.gtz()) {
-            beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][ClaimIdLib.zero()];
+        if(beneficiary == address(0) && payoutId.gtz()) {
+            beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][PayoutIdLib.zero()];
         }
     }
 
@@ -76,14 +84,14 @@ contract PolicyHolder is
         return IERC721Receiver.onERC721Received.selector;
     }
 
-    /// @dev sets policy specific beneficiary (used when no claim specific beneficiary is defined)
+    /// @dev sets policy specific beneficiary (used when no payout specific beneficiary is defined)
     function _setBeneficiary(NftId policyNftId, address beneficiary) internal {
-        _setBeneficiary(policyNftId, ClaimIdLib.zero(), beneficiary);
+        _setBeneficiary(policyNftId, PayoutIdLib.zero(), beneficiary);
     }
 
     /// @dev sets policy and claim specific beneficiary
-    function _setBeneficiary(NftId policyNftId, ClaimId claimId, address beneficiary) internal {
-        _getPolicyHolderStorage()._beneficiary[policyNftId][claimId] = beneficiary;
+    function _setBeneficiary(NftId policyNftId, PayoutId payoutId, address beneficiary) internal {
+        _getPolicyHolderStorage()._beneficiary[policyNftId][payoutId] = beneficiary;
     }
 
     function _getPolicyHolderStorage() private pure returns (PolicyHolderStorage storage $) {

package/contracts/shared/ProxyManager.sol

@@ -11,6 +11,7 @@ import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.s
 import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
 import {UpgradableProxyWithAdmin} from "./UpgradableProxyWithAdmin.sol";
 import {Version, VersionLib} from "../type/Version.sol";
+import {NftId} from "../type/NftId.sol";
 
 /// @dev manages proxy deployments for upgradable contracs of type IVersionable
 contract ProxyManager is
@@ -79,6 +80,31 @@ contract ProxyManager is
         emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
     }
 
+    function deployDetermenistic(address initialImplementation, bytes memory initializationData, bytes32 salt)
+        public
+        virtual
+        onlyOwner()
+        returns (IVersionable versionable)
+    {
+        if (_versions.length > 0) {
+            revert ErrorProxyManagerAlreadyDeployed();
+        }
+
+        address currentProxyOwner = getOwner();
+        address initialProxyAdminOwner = address(this);
+
+        _proxy = new UpgradableProxyWithAdmin{salt: salt}(
+            initialImplementation,
+            initialProxyAdminOwner,
+            getDeployData(currentProxyOwner, initializationData)
+        );
+
+        versionable = IVersionable(address(_proxy));
+        _updateVersionHistory(versionable.getVersion(), initialImplementation, currentProxyOwner);
+
+        emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
+    }
+
     /// @dev upgrade existing contract
     function upgrade(address newImplementation, bytes memory upgradeData)
         public
@@ -106,6 +132,10 @@ contract ProxyManager is
 
     }
 
+    function linkToProxy() public returns (NftId) {
+        return _linkToNftOwnable(address(_proxy));
+    }
+
     function getDeployData(address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
         return abi.encodeWithSelector(
             IVersionable.initializeVersionable.selector, 
@@ -119,7 +149,7 @@ contract ProxyManager is
             upgradeData);
     }
 
-    function getProxy() public returns (UpgradableProxyWithAdmin) {
+    function getProxy() public view returns (UpgradableProxyWithAdmin) {
         return _proxy;
     }
 

package/contracts/shared/Service.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";

package/contracts/staking/IStaking.sol

@@ -2,76 +2,167 @@
 pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
-import {IKeyValueStore} from "../shared/IKeyValueStore.sol";
 import {IComponent} from "../shared/IComponent.sol";
 import {IVersionable} from "../shared/IVersionable.sol";
 import {NftId} from "../type/NftId.sol";
+import {NftIdSetManager} from "../shared/NftIdSetManager.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 
-    IKeyValueStore, 
     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 ErrorStakingLockingPeriodZero(NftId targetNftId);
+    error ErrorStakingLockingPeriodTooLong(NftId targetNftId, Seconds maxLockingPeriod, Seconds lockingPeriod);
+    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 {
-        NftId targetNftId;
-        Amount stakeAmount;
-        Amount rewardAmount;
         Timestamp lockedUntil;
-        Timestamp rewardsUpdatedAt;
     }
 
     struct TargetInfo {
-        NftId targetNftid;
         ObjectType objectType;
         uint256 chainId;
-        address token;
+        Seconds lockingPeriod;
+        UFixed rewardRate;
     }
 
-    // rate management 
+    // 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;
 
-    // reward management 
-    function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
-    function refillRewardReserves(NftId targetNftId, Amount dipAmount) external;
-    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount) external;
 
     // target management
-    function registerTarget(NftId targetNftId) external;
-    function increaseTvl(NftId targetNftId, address token, Amount amount) external;
-    function decreaseTvl(NftId targetNftId, address token, Amount amount) external;
 
-    function registerRemoteTarget(NftId targetNftId, TargetInfo memory targetInfo) external;
+    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
-    function createStake(NftId targetNftId, Amount dipAmount) external returns(NftId stakeNftId);
-    function stake(NftId stakeNftId, Amount dipAmount) external;
-    function restakeRewards(NftId stakeNftId) external;
-    function restakeToNewTarget(NftId stakeNftId, NftId newTarget) external;
-    function unstake(NftId stakeNftId) external;
-    function unstake(NftId stakeNftId, Amount dipAmount) external;  
-    function claimRewards(NftId stakeNftId) external;
 
-    // view and pure functions (staking reader?)
-    function getStakingRate(uint256 chainId, address token) external view returns (UFixed stakingRate);
+    /// @dev creat a new stake info object
+    /// permissioned: only staking service may call this function.
+    function createStake(NftId stakeNftId, NftId targetNftId, Amount dipAmount) external;
 
-    function getRewardRate(NftId targetNftId) external view returns (UFixed rewardRate);
-    function getRewardReserves(NftId targetNftId) external view returns (Amount rewardReserveAmount);
+    /// @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);
 
-    function getStakeInfo() external view returns (NftId stakeNftId);
-    function getTargetInfo() external view returns (NftId stakeNftId);
+    /// @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);
 
-    function getTvlAmount(NftId targetNftId, address token) external view returns (Amount tvlAmount);
-    function getStakedAmount(NftId targetNftId) external view returns (Amount stakeAmount);
+    /// @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
+        );
 
-    function calculateRewardIncrementAmount(
-        NftId targetNftId,
-        Timestamp rewardsLastUpdatedAt
-    ) external view returns (Amount rewardIncrementAmount);
+    /// @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);
 }