@etherisc/gif-next 0.0.2-ec436bf-674 → 0.0.2-ed1536c-164

package/contracts/shared/Versionable.sol

@@ -3,83 +3,39 @@ pragma solidity ^0.8.20;
 
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
-import {Timestamp, TimestampLib} from "../types/Timestamp.sol";
-import {Version, VersionPart, VersionLib} from "../types/Version.sol";
-
 import {IVersionable} from "./IVersionable.sol";
-
+import {Version, VersionLib} from "../type/Version.sol";
 
 
 abstract contract Versionable is 
     Initializable,
     IVersionable 
 {
-    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.shared.Versionable.sol")) - 1)) & ~bytes32(uint256(0xff))
-    bytes32 private constant VERSIONABLE_LOCATION_V1 = 0x4f61291a8ac3d020d0a7d919a76b8592aa88385744dee3f8b4f3873b969ed900;
-
-
-    /// @custom:storage-location erc7201:gif-next.contracts.shared.Versionable.sol
-    struct VersionableStorage {
-        mapping(Version version => VersionInfo info) _versionHistory;
-        Version [] _versions;
-        Version _v1;
-    }
-
-
     constructor() {
         _disableInitializers();
     }
-    // TODO write test where new version of private _updateVersionHistory is added and used... 
-    function initialize(
-        address implementation,
+
+    function initializeVersionable(
         address activatedBy,
         bytes memory data
     )
         public
         initializer
     {
-        _updateVersionHistory(implementation, activatedBy);
         _initialize(activatedBy, data);
     }
 
-    // TODO activatedBy MUST ALWAYS be an owner?
-    function upgrade(
-        address implementation,
-        address activatedBy,
+    function upgradeVersionable(
         bytes memory data
     )
         external
         reinitializer(VersionLib.toUint64(getVersion()))
     {
-        _updateVersionHistory(implementation, activatedBy);
         _upgrade(data);
     }
 
-    function isInitialized(Version _version) public override view returns(bool) {
-        return _getVersionableStorage()._versionHistory[_version].activatedIn.toInt() > 0;
-    }
-
     function getVersion() public pure virtual returns(Version);
 
-    function getVersionCount() public view override returns(uint256) {
-        return _getVersionableStorage()._versions.length;
-    }
-
-    function getVersion(uint256 idx) public view override returns(Version) {
-        return _getVersionableStorage()._versions[idx];
-    }
-
-    function getVersionInfo(Version _version) public override view returns(VersionInfo memory) {
-        return _getVersionableStorage()._versionHistory[_version];
-    }
-
-    function getInitializedVersion() public view returns(uint64) {
-        return _getInitializedVersion();
-    }
-
-
-
     // IMPORTANT each version must implement this function 
     // each implementation MUST use onlyInitialising modifier
     // each implementation MUST call intializers of all base contracts...
@@ -91,7 +47,6 @@ abstract contract Versionable is
         revert();
     }
 
-
     // IMPORTANT each version except version "1" must implement this function 
     // each implementation MUST use onlyInitialising modifier
     function _upgrade(bytes memory data)
@@ -101,47 +56,4 @@ abstract contract Versionable is
     {
         revert();
     }
-
-    function _getVersionableStorage() private pure returns (VersionableStorage storage $) {
-        assembly {
-            $.slot := VERSIONABLE_LOCATION_V1
-        }
-    }
-
-    // can only be called once per contract
-    // needs to be called inside the proxy upgrade tx
-    // TODO run reinitializer(version().toUint64()) modifier after "version()" is checked, 
-    function _updateVersionHistory(
-        address implementation,
-        address activatedBy
-    )
-        private
-        onlyInitializing
-    {
-        VersionableStorage storage $ = _getVersionableStorage();
-
-        uint64 version = _getInitializedVersion();
-
-        Version thisVersion = getVersion();
-
-        if(version == 1) {
-            // thisVersion is alias to version "1"
-            $._v1 = thisVersion;
-        }
-        else {
-            require(thisVersion > $._v1, "INVALID VERSION");
-        }
-
-        // update version history
-        $._versions.push(thisVersion);
-        $._versionHistory[thisVersion] = VersionInfo(
-            thisVersion,
-            implementation,
-            activatedBy,
-            TimestampLib.blockTimestamp(),
-            blockNumber()
-        );
-
-        emit LogVersionableInitialized(thisVersion, implementation, activatedBy);
-    }
 }

package/contracts/staking/IStaking.sol

@@ -0,0 +1,152 @@
+// 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 "../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 
+    IComponent,
+    IVersionable
+{
+
+    // 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);
+
+    // 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 {
+        Timestamp lockedUntil;
+    }
+
+    struct TargetInfo {
+        ObjectType objectType;
+        uint256 chainId;
+        Seconds lockingPeriod;
+        UFixed rewardRate;
+    }
+
+    // rate management 
+    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.
+    function setLockingPeriod(NftId targetNftId, Seconds lockingPeriod) external;
+
+    function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
+    function refillRewardReserves(NftId targetNftId, Amount dipAmount) external;
+    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount) external;
+
+    function increaseTvl(NftId targetNftId, address token, Amount amount) external;
+    function decreaseTvl(NftId targetNftId, address token, Amount amount) external;
+
+    function updateRemoteTvl(NftId targetNftId, address token, Amount amount) external;
+
+    // staking functions
+
+    /// @dev register a new stake info object
+    /// permissioned: only staking service may call this function.
+    function registerStake(NftId stakeNftId, NftId targetNftId, Amount dipAmount) external;
+
+    /// @dev increase the staked dip by dipAmount for the specified stake
+    function stake(NftId stakeNftId, Amount dipAmount) external;
+
+    /// @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) external;
+
+    /// @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);
+
+    // function getStakeInfo(NftId stakeNftId) external view returns (StakeInfo memory stakeInfo);
+    // function getTargetInfo(NftId targetNftId) external view returns (TargetInfo memory targetInfo);
+
+    function getTvlAmount(NftId targetNftId, address token) external view returns (Amount tvlAmount);
+    function getStakedAmount(NftId targetNftId) external view returns (Amount stakeAmount);
+
+    function getStakingRate(uint256 chainId, address token) external view returns (UFixed stakingRate);
+
+    function calculateRewardIncrementAmount(
+        NftId targetNftId,
+        Timestamp rewardsLastUpdatedAt
+    ) external view returns (Amount rewardIncrementAmount);
+
+}

package/contracts/staking/IStakingManager.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+interface IStakingManager {
+
+    /// @dev initializes staking manager with authority of registry access manager.
+    function initialize(
+        address authority
+    )
+        external;
+
+
+    function getStakingAddress() external view returns (address staking);
+
+}

package/contracts/staking/IStakingService.sol

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {IService} from "../shared/IService.sol";
+import {IStaking} from "./IStaking.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {UFixed} from "../type/UFixed.sol";
+
+
+interface IStakingService is IService
+{
+
+    event LogStakingServiceProtocolTargetRegistered(NftId protocolNftId);
+    event LogStakingServiceInstanceTargetRegistered(NftId instanceNftId, uint256 chainId);
+    event LogStakingServiceLockingPeriodSet(NftId targetNftId, Seconds oldLockingDuration, Seconds lockingDuration);
+    event LogStakingServiceRewardRateSet(NftId targetNftId, UFixed oldRewardRate, UFixed rewardRate);
+
+    event LogStakingServiceStakeCreated(NftId stakeNftId, NftId targetNftId, address owner, Amount stakedAmount);
+    event LogStakingServiceStakeIncreased(NftId stakeNftId, address owner, Amount stakedAmount);
+    event LogStakingServiceRewardsUpdated(NftId stakeNftId);
+
+    // modifiers
+    error ErrorStakingServiceNotNftOwner(NftId nftId, address expectedOwner, address owner);
+    error ErrorStakingServiceNotStaking(address stakingAddress);
+    error ErrorStakingServiceNotSupportingIStaking(address stakingAddress);
+
+    // create
+    error ErrorStakingServiceZeroTargetNftId();
+    error ErrorStakingServiceNotTargetNftId(NftId targetNftId);
+    error ErrorStakingServiceNotActiveTargetNftId(NftId targetNftId);
+    error ErrorStakingServiceDipBalanceInsufficient(NftId targetNftId, uint256 amount, uint256 balance);
+    error ErrorStakingServiceDipAllowanceInsufficient(NftId targetNftId, address tokenHandler, uint256 amount, uint256 allowance);
+
+    /// @dev creates/registers an on-chain instance staking target.
+    /// function granted to instance service
+    function createInstanceTarget(
+        NftId targetNftId,
+        Seconds initialLockingPeriod,
+        UFixed initialRewardRate
+    ) external;
+
+    /// @dev set the stake locking period to the specified duration.
+    /// permissioned: only the owner of the specified target may set the locking period
+    function setLockingPeriod(NftId targetNftId, Seconds lockingPeriod) external;
+
+    /// @dev set the reward rate to the specified value
+    /// permissioned: only the owner of the specified target may set the locking period
+    function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
+
+    /// @dev create a new stake with amount DIP to the specified target
+    /// returns the id of the newly minted stake nft
+    /// permissionless function
+    function create(
+        NftId targetNftId,
+        Amount amount
+    )
+        external
+        returns (
+            NftId stakeNftId
+        );
+
+
+    /// @dev increase an existing stake by amount DIP
+    /// updates the staking reward amount
+    /// function restricted to the current stake owner
+    function stake(
+        NftId stakeNftId,
+        Amount amount
+    )
+        external;
+
+
+    /// @dev re-stakes the current staked DIP as well as all accumulated rewards to the new stake target.
+    /// all related stakes and all accumulated reward DIP are transferred to the current stake holder
+    /// function restricted to the current stake owner
+    function restake(
+        NftId stakeNftId
+    )
+        external;
+
+
+    /// @dev re-stakes the current staked DIP as well as all accumulated rewards to the new stake target.
+    /// all related stakes and all accumulated reward DIP are transferred to the current stake holder
+    /// function restricted to the current stake owner
+    function restakeToNewTarget(
+        NftId stakeNftId,
+        NftId newTargetNftId
+    )
+        external
+        returns (
+            NftId newStakeNftId
+        );
+
+
+    /// @dev decrease an existing stake by amount DIP
+    /// updates the staking reward amount
+    /// function restricted to the current stake owner
+    function unstake(
+        NftId stakeNftId,
+        Amount amount
+    )
+        external;
+
+    /// @dev updates the reward balance of the stake using the current reward rate.
+    function updateRewards(
+        NftId stakeNftId
+    )
+        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 totalValueLocked);
+
+
+    /// @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 totalValueLocked);
+
+
+    /// @dev sets total value locked data for a target contract on a different chain.
+    /// this is done via CCIP (cross chain communication) 
+    function setTotalValueLocked(
+        NftId targetNftId,
+        address token,
+        Amount amount
+    )
+        external;
+
+    function getDipToken()
+        external
+        returns (IERC20Metadata dip);
+
+    function getTokenHandler()
+        external
+        returns (TokenHandler tokenHandler);
+
+    function getStaking()
+        external
+        returns (IStaking staking);
+}

package/contracts/staking/IStakingStore.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
+import {ChainNft} from "../registry/ChainNft.sol";
+import {Component} from "../shared/Component.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
+import {IStaking} from "./IStaking.sol";
+import {IVersionable} from "../shared/IVersionable.sol";
+import {Key32} from "../type/Key32.sol";
+import {KeyValueStore} from "../shared/KeyValueStore.sol";
+import {KEEP_STATE} from "../type/StateId.sol";
+import {LibNftIdSet} from "../type/NftIdSet.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {NftIdSetManager} from "../shared/NftIdSetManager.sol";
+import {ObjectType, INSTANCE, PROTOCOL, STAKE, STAKING, TARGET} from "../type/ObjectType.sol";
+import {Seconds, SecondsLib} from "../type/Seconds.sol";
+import {StakingReader} from "./StakingReader.sol";
+import {TargetManagerLib} from "./TargetManagerLib.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+import {TokenRegistry} from "../registry/TokenRegistry.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
+import {Version, VersionLib} from "../type/Version.sol";
+import {Versionable} from "../shared/Versionable.sol";
+
+
+interface IStakingStore {
+
+    // event LogStakingStoreStakesIncreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    // event LogStakingStoreStakesDecreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    // event LogStakingStoreRewardsIncreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    // event LogStakingStoreRewardsDecreased(NftId nftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    // event LogStakingStoreRewardsRestaked(NftId nftId, Amount amount, Amount rewardAmount, Amount rewardIncrementAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    // // creating and updating of balance
+    // error ErrorStakingStoreBalanceAlreadyInitialized(NftId nftId);
+    // error ErrorStakingStoreBalanceNotInitialized(NftId nftId);
+
+    //--- target specific functions ------------------------------------//
+
+    function createTarget(
+        NftId targetNftId,
+        IStaking.TargetInfo memory targetInfo
+    )
+        external;
+
+
+    function updateTarget(
+        NftId targetNftId, 
+        IStaking.TargetInfo memory targetInfo
+    )
+        external;
+
+    //--- stake specific functions -------------------------------------//
+
+    function create(
+        NftId stakeNftId, 
+        IStaking.StakeInfo memory stakeInfo,
+        Amount stakeAmount
+    )
+        external;
+
+    function update(
+        NftId stakeNftId, 
+        IStaking.StakeInfo memory stakeInfo
+    )
+        external;
+
+    //--- general functions --------------------------------------------//
+
+
+    function increaseBalance(NftId nftId, Amount amount, Amount rewardIncrementAmount)
+        external;
+
+
+    function restakeRewards(
+        NftId nftId, 
+        Amount rewardIncrementAmount
+    )
+        external;
+
+
+    function updateRewards(
+        NftId nftId, 
+        Amount rewardIncrementAmount
+    )
+        external;
+
+
+    function claimUpTo(
+        NftId nftId, 
+        Amount maxRewardAmount
+    )
+        external
+        returns (Amount rewardsClaimedAmount);
+
+
+    function unstakeUpTo(
+        NftId nftId, 
+        Amount maxUnstakeAmount,
+        Amount maxClaimAmount
+    )
+        external
+        returns (
+            Amount unstakedAmount,
+            Amount claimedAmount
+        );
+
+    //--- view functions -----------------------------------------------//
+
+    function getTargetManager() external view returns (NftIdSetManager targetManager);
+
+    function getStakeBalance(NftId nftId) external view returns (Amount balanceAmount);
+    function getRewardBalance(NftId nftId) external view returns (Amount rewardAmount);
+    function getBalanceUpdatedAt(NftId nftId) external view returns (Timestamp updatedAt);
+
+    function getBalanceAndLastUpdatedAt(NftId nftId)
+        external
+        view
+        returns (
+            Amount stakeBalance,
+            Timestamp lastUpdatedAt
+        );
+}