@etherisc/gif-next 0.0.2-e6a90b9 → 0.0.2-e769e2e-077

package/contracts/staking/Staking.sol

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: Apache-2.0
+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 {ObjectType, REGISTRY, STAKING} from "../type/ObjectType.sol";
+import {NftId} from "../type/NftId.sol";
+import {Version, VersionLib, VersionPartLib} from "../type/Version.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {Component} from "../shared/Component.sol";
+import {IStaking} from "./IStaking.sol";
+import {IVersionable} from "../shared/IVersionable.sol";
+import {KeyValueStore} from "../shared/KeyValueStore.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {Versionable} from "../shared/Versionable.sol";
+
+import {IRegistry} from "../registry/IRegistry.sol";
+
+contract Staking is 
+    KeyValueStore,
+    Component,
+    Versionable,
+    IStaking
+{
+    string public constant CONTRACT_NAME = "Staking";
+    uint8 private constant GIF_MAJOR_VERSION = 3;
+
+    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.component.Staking.sol")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant STAKING_LOCATION_V1 = 0xafe8d4462b2ed26a47154f4b8f6d1497d2f772496965791d25bd456e342b7f00;
+
+    struct StakingStorage {
+        mapping(uint256 chainId => mapping(address token => UFixed stakingRate)) _stakingRate;
+        mapping(NftId targetNftId => UFixed rewardRate) _rewardRate;
+        mapping(NftId targetNftId => Amount reserveAmount) _rewardReserveAmount;
+        mapping(NftId targetNftId => Amount stakedAmount) _stakedAmount;
+        mapping(NftId targetNftId => mapping(address token => Amount tvlAmount)) _tvlAmount;
+    }
+
+    function _getStakingStorage() private pure returns (StakingStorage storage $) {
+        assembly {
+            $.slot := STAKING_LOCATION_V1
+        }
+    }
+
+    // from Versionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(GIF_MAJOR_VERSION,0,0);
+    }
+
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        virtual override
+        initializer
+    {
+        (
+            address initialAuthority,
+            address registryAddress,
+            address dipTokenAddress,
+            address initialOwner
+        ) = abi.decode(data, (address, address, address, address));
+
+        initializeComponent(
+            initialAuthority,
+            registryAddress, 
+            IRegistry(registryAddress).getNftId(), 
+            CONTRACT_NAME,
+            dipTokenAddress,
+            STAKING(), 
+            false, // is interceptor
+            initialOwner, 
+            "", // registry data
+            ""); // component data
+
+        // create the staking token handler
+        _createAndSetTokenHandler();
+
+        registerInterface(type(IStaking).interfaceId);
+    }
+
+    // rate management 
+    function setStakingRate(uint256 chainId, address token, UFixed stakingRate)
+        external
+        virtual
+        onlyOwner
+    {
+
+    }
+
+    // reward management 
+    function setRewardRate(NftId targetNftId, UFixed rewardRate)
+        external
+        virtual
+        // onlyNftOwner(targetNftId)
+    {
+        
+    }
+
+    function refillRewardReserves(NftId targetNftId, Amount dipAmount)
+        external
+        virtual
+    {
+
+    }
+
+    function withdrawRewardReserves(NftId targetNftId, Amount dipAmount)
+        external
+        virtual
+        // onlyNftOwner(targetNftId)
+    {
+        
+    }
+
+    // target management
+    function registerTarget(NftId targetNftId)
+        external
+        virtual
+        // restricted // service to service access
+    {
+
+    }
+
+    function increaseTvl(NftId targetNftId, address token, Amount amount)
+        external
+        virtual
+        // restricted // service to service access
+    {
+
+    }
+
+    function decreaseTvl(NftId targetNftId, address token, Amount amount)
+        external
+        virtual
+        // restricted // service to service access
+    {
+
+    }
+
+
+    function registerRemoteTarget(NftId targetNftId, TargetInfo memory targetInfo)
+        external
+        virtual
+        onlyOwner // or CCIP
+    {
+        
+    }
+
+    function updateRemoteTvl(NftId targetNftId, address token, Amount amount)
+        external
+        virtual
+        onlyOwner // or CCIP
+    {
+        
+    }
+
+    // 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) {
+        return _getStakingStorage()._stakingRate[chainId][token];
+    }
+
+    function getRewardRate(NftId targetNftId) external view returns (UFixed rewardRate) {
+        return _getStakingStorage()._rewardRate[targetNftId];
+    }
+
+    function getRewardReserves(NftId targetNftId) external view returns (Amount rewardReserveAmount)  {
+        return _getStakingStorage()._rewardReserveAmount[targetNftId];
+    }
+
+
+    function getStakeInfo() external view returns (NftId stakeNftId) {}
+    function getTargetInfo() external view returns (NftId stakeNftId) {}
+
+    function getTvlAmount(NftId targetNftId, address token) external view returns (Amount tvlAmount) {
+        return _getStakingStorage()._tvlAmount[targetNftId][token];
+    }
+
+    function getStakedAmount(NftId targetNftId) external view returns (Amount stakeAmount) {
+        return _getStakingStorage()._stakedAmount[targetNftId];
+    }
+
+    function calculateRewardIncrementAmount(
+        NftId targetNftId,
+        Timestamp rewardsLastUpdatedAt
+    )
+        public 
+        virtual
+        view 
+        returns (Amount rewardIncrementAmount)
+    {
+
+    }
+
+}

package/contracts/staking/StakingManager.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../shared/IVersionable.sol";
+import {ProxyManager} from "../shared/ProxyManager.sol";
+import {Staking} from "./Staking.sol";
+
+contract StakingManager is
+    ProxyManager
+{
+
+    Staking private _staking;
+
+    /// @dev initializes proxy manager with service implementation 
+    constructor(
+        address initialAuthority,
+        address registryAddress,
+        address dipTokenAddress
+    )
+        ProxyManager(registryAddress)
+    {
+        Staking stk = new Staking();
+        address initialOwner = msg.sender;
+
+        bytes memory data = abi.encode(
+            initialAuthority, 
+            registryAddress, 
+            dipTokenAddress, 
+            initialOwner);
+
+        IVersionable versionable = deploy(
+            address(stk), 
+            data);
+
+        _staking = Staking(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getStaking()
+        external
+        view
+        returns (Staking)
+    {
+        return _staking;
+    }
+}

package/contracts/staking/StakingService.sol

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Amount} from "../type/Amount.sol";
+import {IPoolService} from "../pool/IPoolService.sol";
+import {IRegisterable} from "../shared/IRegisterable.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
+import {IStaking} from "./IStaking.sol";
+import {IStakingService} from "./IStakingService.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, POOL, REGISTRY, STAKE, STAKING} from "../type/ObjectType.sol";
+import {Service} from "../shared/Service.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+contract StakingService is 
+    Service, 
+    IStakingService
+{
+    // TODO decide and implement string spec for location calculation
+    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.shared.StakingService.sol")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant STAKING_SERVICE_LOCATION_V1 = 0x6548005c3f4340f82f348c576c0ff69f7f529cadd5ad41f96aae61abceeaa300;
+
+    struct StakingServiceStorage {
+        IStaking _staking;
+    }
+
+    function getDomain() public pure override returns(ObjectType) {
+        return STAKING();
+    }
+
+
+    function create(
+        NftId targetNftId,
+        Amount amount
+    )
+        external
+        virtual
+        returns (
+            NftId stakeNftId
+        )
+    {
+
+    }
+
+
+    function stake(
+        NftId stakeNftId,
+        Amount amount
+    )
+        external
+        virtual
+    {
+
+    }
+
+
+    function unstake(
+        NftId stakeNftId,
+        Amount amount
+    )
+        external
+        virtual
+    {
+
+    }
+
+    function close(
+        NftId stakeNftId
+    )
+        external
+        virtual
+    {
+
+    }
+
+    function reStake(
+        NftId stakeNftId,
+        NftId newTargetNftId
+    )
+        external
+        virtual
+        returns (
+            NftId newStakeNftId,
+            Timestamp unlockedAt
+        )
+    {
+
+    }
+
+
+    function increaseTotalValueLocked(
+        NftId targetNftId,
+        address token,
+        Amount amount
+    )
+        external
+        virtual
+        returns (Amount totalValueLocked)
+    {
+
+    }
+
+
+    function decreaseTotalValueLocked(
+        NftId targetNftId,
+        address token,
+        Amount amount
+    )
+        external
+        virtual
+        returns (Amount totalValueLocked)
+    {
+
+    }
+
+
+    function setTotalValueLocked(
+        NftId targetNftId,
+        address token,
+        Amount amount
+    )
+        external
+        virtual
+    {
+
+    }
+
+    function getStaking()
+        external
+        virtual
+        returns (IStaking staking)
+    {
+        return _getStakingServiceStorage()._staking;
+    }
+
+
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        virtual override
+        initializer()
+    {
+        (
+            address registryAddress,
+            address stakingAddress
+        ) = abi.decode(data, (address, address));
+
+        initializeService(registryAddress, address(0), owner);
+
+        StakingServiceStorage storage $ = _getStakingServiceStorage();
+        $._staking = _registerStaking(stakingAddress);
+
+        registerInterface(type(IStakingService).interfaceId);
+    }
+
+
+    function _registerStaking(
+        address stakingAddress
+    )
+        internal
+        returns (IStaking staking)
+    {
+        // check if provided staking contract is already registred
+        // staking contract may have been already registered by a previous major relase
+        IRegistry.ObjectInfo memory stakingInfo = getRegistry().getObjectInfo(stakingAddress);
+        if (stakingInfo.nftId.gtz()) {
+            // registered object but wrong type
+            if (stakingInfo.objectType != STAKING()) {
+                revert ErrorStakingServiceNotStaking(stakingAddress);
+            }
+
+            // return correctly registered staking contract
+            return IStaking(stakingAddress);
+        }
+
+        // check that contract implements IStaking
+        if(!IStaking(stakingAddress).supportsInterface(type(IStaking).interfaceId)) {
+            revert ErrorStakingServiceNotSupportingIStaking(stakingAddress);
+        }
+
+        address owner = msg.sender;
+        IRegistryService(
+            _getServiceAddress(REGISTRY())).registerStaking(
+                IRegisterable(stakingAddress),
+                owner);
+
+        return IStaking(stakingAddress);
+    }
+
+
+    function _getStakingServiceStorage() private pure returns (StakingServiceStorage storage $) {
+        assembly {
+            $.slot := STAKING_SERVICE_LOCATION_V1
+        }
+    }
+}

package/contracts/staking/StakingServiceManager.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IVersionable} from "../shared/IVersionable.sol";
+import {ProxyManager} from "../shared/ProxyManager.sol";
+import {StakingService} from "./StakingService.sol";
+
+contract StakingServiceManager is
+    ProxyManager
+{
+
+    StakingService private _stakingService;
+
+    /// @dev initializes proxy manager with service implementation 
+    constructor(
+        address registryAddress
+    )
+        ProxyManager(registryAddress)
+    {
+        StakingService svc = new StakingService();
+        bytes memory data = abi.encode(
+            registryAddress, 
+            IRegistry(registryAddress).getStakingAddress());
+
+        IVersionable versionable = deploy(
+            address(svc), 
+            data);
+
+        _stakingService = StakingService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getStakingService()
+        external
+        view
+        returns (StakingService)
+    {
+        return _stakingService;
+    }
+}

package/contracts/type/AddressSet.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/structs/EnumerableSet.sol
+library LibAddressSet {
+
+    struct Set {
+        address[] elements;
+        mapping(address element => uint256 index) at;
+    }
+
+    function add(Set storage set, address element) external returns(bool added) {
+        if (set.at[element] == 0) {
+            set.elements.push(element);
+            set.at[element] = set.elements.length;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function remove(Set storage set, address element) external returns(bool removed) {
+        uint256 elementIndex = set.at[element];
+
+        if (elementIndex > 0) {
+            uint256 toDeleteIndex = elementIndex - 1;
+            uint256 lastIndex = set.elements.length - 1;
+
+            if (lastIndex != toDeleteIndex) {
+                address lastElement = set.elements[lastIndex];
+                set.elements[toDeleteIndex] = lastElement;
+                set.at[lastElement] = elementIndex; // Replace lastValue's index to valueIndex
+            }
+
+            set.elements.pop();
+            delete set.at[element];
+            return true;
+        }
+        
+        return false;
+    }
+
+    function isEmpty(Set storage set) external view returns(bool empty) {
+        return set.elements.length == 0;
+    }
+
+    function contains(Set storage set, address element) external view returns(bool inSet) {
+        return set.at[element] > 0;
+    }
+
+    function getLength(Set storage set) external view returns(uint256 length) {
+        return set.elements.length;
+    }
+
+    function getElementAt(Set storage set, uint256 index) external view returns(address element) {
+        return set.elements[index];
+    }
+}

package/contracts/type/Amount.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {UFixed, UFixedLib} from "./UFixed.sol";
+
+type Amount is uint96;
+
+using {
+    addAmount as +,
+    subAmount as -,
+    eqAmount as ==,
+    nqAmount as !=,
+    ltAmount as <,
+    gtAmount as >,
+    AmountLib.eq,
+    AmountLib.eqz,
+    AmountLib.gtz,
+    AmountLib.toInt,
+    AmountLib.add,
+    AmountLib.toUFixed
+} for Amount global;
+
+function addAmount(Amount a, Amount b) pure returns (Amount) {
+    return AmountLib.add(a, b);
+}
+
+function subAmount(Amount a, Amount b) pure returns (Amount) {
+    return AmountLib.sub(a, b);
+}
+
+function eqAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.eq(a, b);
+}
+
+function nqAmount(Amount a, Amount b) pure returns (bool) {
+    return !AmountLib.eq(a, b);
+}
+
+function ltAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.lt(a, b);
+}
+
+function gtAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.gt(a, b);
+}
+
+library AmountLib {
+
+    error ErrorAmountLibValueTooBig(uint256 amount);
+
+    function zero() public pure returns (Amount) {
+        return Amount.wrap(0);
+    }
+
+    function max() public pure returns (Amount) {
+        return Amount.wrap(_max());
+    }
+
+    /// @dev converts the uint amount into Amount
+    /// function reverts if value is exceeding max Amount value
+    function toAmount(uint256 amount) public pure returns (Amount) {
+        if(amount > _max()) {
+            revert ErrorAmountLibValueTooBig(amount);
+        }
+
+        return Amount.wrap(uint96(amount));
+    }
+
+    /// @dev return true if amount equals 0
+    function eqz(Amount amount) public pure returns (bool) {
+        return Amount.unwrap(amount) == 0;
+    }
+
+    /// @dev return true if amount1 equals amount2
+    function eq(Amount amount1, Amount amount2) public pure returns (bool) {
+        return Amount.unwrap(amount1) == Amount.unwrap(amount2);
+    }
+
+    /// @dev return true if amount a1 is smaller than a2
+    function lt(Amount a1, Amount a2) public pure returns (bool) {
+        return Amount.unwrap(a1) < Amount.unwrap(a2);
+    }
+
+    /// @dev return true if amount a1 is larger than a2
+    function gt(Amount a1, Amount a2) public pure returns (bool) {
+        return Amount.unwrap(a1) > Amount.unwrap(a2);
+    }
+
+    /// @dev return true if amount is larger than 0
+    function gtz(Amount amount) public pure returns (bool) {
+        return Amount.unwrap(amount) > 0;
+    }
+
+    function add(Amount a1, Amount a2) public pure returns (Amount) {
+        return Amount.wrap(Amount.unwrap(a1) + Amount.unwrap(a2));
+    }
+
+    function sub(Amount a1, Amount a2) public pure returns (Amount) {
+        return Amount.wrap(Amount.unwrap(a1) - Amount.unwrap(a2));
+    }
+
+    function toInt(Amount amount) public pure returns (uint256) {
+        return uint256(uint96(Amount.unwrap(amount)));
+    }
+
+    function toUFixed(Amount amount) public pure returns (UFixed) {
+        return UFixedLib.toUFixed(Amount.unwrap(amount));
+    }
+
+    function _max() internal pure returns (uint96) {
+        // IMPORTANT: type nees to match with actual definition for Amount
+        return type(uint96).max;
+    }
+}