@etherisc/gif-next 0.0.2-9a680f3-735 → 0.0.2-9aa0884-641

package/contracts/registry/IRelease.sol

@@ -11,13 +11,16 @@ import {VersionPart} from "../type/Version.sol";
 interface IRelease {
 
     struct ReleaseInfo {
+        // slot 0
+        address releaseAdmin;
         StateId state;
         VersionPart version;
-        bytes32 salt;
-        IServiceAuthorization auth;
-        address releaseAdmin;
         Timestamp activatedAt;
         Timestamp disabledAt;
+        // slot 1
+        IServiceAuthorization auth;
+        // slot 2
+        bytes32 salt;
     }
 
     /// @dev Registers a registry contract for a specified chain.

package/contracts/registry/RegistryAuthorization.sol

@@ -206,6 +206,7 @@ contract RegistryAuthorization
           _authorize(functions, IStaking.registerTarget.selector, "registerTarget");
           _authorize(functions, IStaking.setLockingPeriod.selector, "setLockingPeriod");
           _authorize(functions, IStaking.setRewardRate.selector, "setRewardRate");
+          _authorize(functions, IStaking.setMaxStakedAmount.selector, "setMaxStakedAmount");
           _authorize(functions, IStaking.refillRewardReserves.selector, "refillRewardReserves");
           _authorize(functions, IStaking.withdrawRewardReserves.selector, "withdrawRewardReserves");
           _authorize(functions, IStaking.createStake.selector, "createStake");

package/contracts/registry/ServiceAuthorizationV3.sol

@@ -111,6 +111,7 @@ contract ServiceAuthorizationV3
           _authorize(functions, IStakingService.createInstanceTarget.selector, "createInstanceTarget");
           _authorize(functions, IStakingService.setInstanceLockingPeriod.selector, "setInstanceLockingPeriod");
           _authorize(functions, IStakingService.setInstanceRewardRate.selector, "setInstanceRewardRate");
+          _authorize(functions, IStakingService.setInstanceMaxStakedAmount.selector, "setInstanceMaxStakedAmount");
           _authorize(functions, IStakingService.refillInstanceRewardReserves.selector, "refillInstanceRewardReserves");
           _authorize(functions, IStakingService.withdrawInstanceRewardReserves.selector, "withdrawInstanceRewardReserves");
 
@@ -139,6 +140,7 @@ contract ServiceAuthorizationV3
 
           _authorize(functions, IInstanceService.setStakingLockingPeriod.selector, "setStakingLockingPeriod");
           _authorize(functions, IInstanceService.setStakingRewardRate.selector, "setStakingRewardRate");
+          _authorize(functions, IInstanceService.setStakingMaxAmount.selector, "setStakingMaxAmount");
           _authorize(functions, IInstanceService.refillStakingRewardReserves.selector, "refillStakingRewardReserves");
           _authorize(functions, IInstanceService.withdrawStakingRewardReserves.selector, "withdrawStakingRewardReserves");
      }

package/contracts/registry/TokenRegistry.sol

@@ -35,10 +35,13 @@ contract TokenRegistry is
     error ErrorTokenRegistryMajorVersionInvalid(VersionPart majorVersion);
 
     struct TokenInfo {
+        // slot 0
         uint256 chainId;
+        // slot 1
+        string symbol;
+        // slot 2
         address token;
         uint8 decimals;
-        string symbol;
         bool active;
     }
 

package/contracts/shared/Component.sol

@@ -5,17 +5,14 @@ import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessMana
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
 import {Amount} from "../type/Amount.sol";
-import {ContractLib} from "./ContractLib.sol";
 import {IComponent} from "./IComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "./IComponentService.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {IRelease} from "../registry/IRelease.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, STAKING} from "../type/ObjectType.sol";
+import {ObjectType, COMPONENT} from "../type/ObjectType.sol";
 import {Registerable} from "../shared/Registerable.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
-import {Version, VersionLib, VersionPart} from "../type/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
 
 
 abstract contract Component is
@@ -27,7 +24,6 @@ abstract contract Component is
 
     struct ComponentStorage {
         string _name; // unique (per instance) component name
-        IERC20Metadata _token; // token for this component
         bool _isInterceptor;
         bytes _data;
         IComponentService _componentService;
@@ -43,6 +39,7 @@ abstract contract Component is
 
 
     function _getComponentStorage() private pure returns (ComponentStorage storage $) {
+        // solhint-disable-next-line no-inline-assembly
         assembly {
             $.slot := COMPONENT_LOCATION_V1
         }
@@ -54,7 +51,6 @@ abstract contract Component is
         address registry,
         NftId parentNftId,
         string memory name,
-        address token,
         ObjectType componentType,
         bool isInterceptor,
         address initialOwner,
@@ -65,20 +61,6 @@ abstract contract Component is
         virtual
         onlyInitializing()
     {
-        address tokenRegistry = IRegistry(registry).getTokenRegistryAddress();
-        VersionPart release = IRelease(authority).getRelease();
-
-        // special case for staking: component intitialization happens before
-        // GIF core contract setup is complete. at that time token registry 
-        // is not yet available. therefore we skip the check for staking.
-        if (componentType != STAKING()) {
-
-            // check if provided token is whitelisted and active
-            if (!ContractLib.isActiveToken(tokenRegistry, token, block.chainid, release)) {
-                revert ErrorComponentTokenInvalid(token);
-            }
-        }
-
         if (bytes(name).length == 0) {
             revert ErrorComponentNameLengthZero();
         }
@@ -95,7 +77,6 @@ abstract contract Component is
         // set component state
         ComponentStorage storage $ = _getComponentStorage();
         $._name = name;
-        $._token = IERC20Metadata(token);
         $._isInterceptor = isInterceptor;
         $._data = componentData;
         $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
@@ -125,7 +106,7 @@ abstract contract Component is
     }
 
     function getToken() public view virtual returns (IERC20Metadata token) {
-        return getComponentInfo().token;
+        return getTokenHandler().TOKEN();
     }
 
     function getName() public view override returns(string memory name) {
@@ -183,7 +164,10 @@ abstract contract Component is
     function _nftTransferFrom(address from, address to, uint256 tokenId, address operator)
         internal
         virtual
-    { }
+    // solhint-disable-next-line no-empty-blocks
+    { 
+        // empty default implementation
+    }
 
 
     /// @dev Sets the components wallet to the specified address.
@@ -213,7 +197,6 @@ abstract contract Component is
         
         return IComponents.ComponentInfo({
             name: $._name,
-            token: $._token,
             tokenHandler: TokenHandler(address(0)),
             data: $._data // user specific component data
         });

package/contracts/shared/ComponentService.sol

@@ -19,6 +19,7 @@ import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
 
+import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {ContractLib} from "../shared/ContractLib.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
@@ -98,15 +99,18 @@ contract ComponentService is
         returns (NftId componentNftId)
     {
         // type specific registration
-        ObjectType componentType = IInstanceLinkedComponent(component).getInitialInfo().objectType;
+        IRegistry.ObjectInfo memory componentObjectInfo = IInstanceLinkedComponent(component).getInitialInfo();
+        ObjectType componentType = componentObjectInfo.objectType;        
+        IComponent productComponent = IComponent(getRegistry().getObjectAddress(componentObjectInfo.parentNftId));
+
         if (componentType == POOL()) {
-            return _registerPool(component);
+            return _registerPool(component, address(productComponent.getToken()));
         }
         if (componentType == DISTRIBUTION()) {
-            return _registerDistribution(component);
+            return _registerDistribution(component, address(productComponent.getToken()));
         }
         if (componentType == ORACLE()) {
-            return _registerOracle(component);
+            return _registerOracle(component, address(productComponent.getToken()));
         }
 
         // fail
@@ -210,7 +214,7 @@ contract ComponentService is
 
     //-------- product ------------------------------------------------------//
 
-    function registerProduct(address productAddress)
+    function registerProduct(address productAddress, address token)
         external
         virtual
         nonReentrant()
@@ -222,7 +226,8 @@ contract ComponentService is
         InstanceStore instanceStore;
         (, instanceAdmin, instanceStore,, productNftId) = _register(
             productAddress,
-            PRODUCT());
+            PRODUCT(),
+            token);
 
         // get product
         IProductComponent product = IProductComponent(productAddress);
@@ -280,7 +285,7 @@ contract ComponentService is
     //-------- distribution -------------------------------------------------//
 
     /// @dev registers the sending component as a distribution component
-    function _registerDistribution(address distributioAddress)
+    function _registerDistribution(address distributioAddress, address token)
         internal
         virtual
         nonReentrant()
@@ -293,7 +298,8 @@ contract ComponentService is
         NftId productNftId;
         (instanceReader, instanceAdmin, instanceStore, productNftId, distributionNftId) = _register(
             distributioAddress,
-            DISTRIBUTION());
+            DISTRIBUTION(),
+            token);
 
         // check product is still expecting a distribution registration
         IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
@@ -344,7 +350,7 @@ contract ComponentService is
 
     //-------- oracle -------------------------------------------------------//
 
-    function _registerOracle(address oracleAddress)
+    function _registerOracle(address oracleAddress, address token)
         internal
         virtual
         returns (NftId oracleNftId)
@@ -357,7 +363,8 @@ contract ComponentService is
 
         (instanceReader, instanceAdmin, instanceStore, productNftId, oracleNftId) = _register(
             oracleAddress,
-            ORACLE());
+            ORACLE(),
+            token);
 
         // check product is still expecting an oracle registration
         IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
@@ -376,7 +383,7 @@ contract ComponentService is
 
     //-------- pool ---------------------------------------------------------//
 
-    function _registerPool(address poolAddress)
+    function _registerPool(address poolAddress, address token)
         internal
         virtual
         returns (NftId poolNftId)
@@ -389,7 +396,8 @@ contract ComponentService is
 
         (instanceReader, instanceAdmin, instanceStore, productNftId, poolNftId) = _register(
             poolAddress,
-            POOL());
+            POOL(),
+            token);
 
         // check product is still expecting a pool registration
         IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
@@ -453,7 +461,8 @@ contract ComponentService is
     /// @dev Registers the component represented by the provided address.
     function _register(
         address componentAddress, // address of component to register
-        ObjectType requiredType // required type for component for registration
+        ObjectType requiredType, // required type for component for registration
+        address token
     )
         internal
         virtual
@@ -481,6 +490,18 @@ contract ComponentService is
             componentAddress,
             requiredType);
 
+        if (! instance.isTokenRegistryDisabled()) {
+            // check if provided token is whitelisted and active
+            if (!ContractLib.isActiveToken(
+                getRegistry().getTokenRegistryAddress(), 
+                token, 
+                block.chainid, 
+                AccessManagerCloneable(authority()).getRelease())
+            ) {
+                revert ErrorComponentServiceTokenInvalid(token);
+            }
+        }
+
         // get instance supporting contracts (as function return values)
         instanceReader = instance.getInstanceReader();
         instanceAdmin = instance.getInstanceAdmin();
@@ -496,10 +517,8 @@ contract ComponentService is
         }
 
         // deploy and wire token handler
-        address token;
         {
             IComponents.ComponentInfo memory componentInfo = component.getInitialComponentInfo();
-            token = address(componentInfo.token);
             componentInfo.tokenHandler = TokenHandlerDeployerLib.deployTokenHandler(
                 address(getRegistry()),
                 componentAddress, // initially, component is its own wallet

package/contracts/shared/IComponent.sol

@@ -15,9 +15,6 @@ interface IComponent is
     IRegisterable,
     ITransferInterceptor
 {
-
-    error ErrorComponentTokenInvalid(address token);
-
     error ErrorComponentProductNftIdZero();
     error ErrorComponentProductNftIdNonzero();
     error ErrorComponentNameLengthZero();

package/contracts/shared/IComponentService.sol

@@ -16,6 +16,8 @@ import {VersionPart} from "../type/Version.sol";
 interface IComponentService is 
     IService
 {
+    error ErrorComponentServiceTokenInvalid(address token);
+
     error ErrorComponentServiceNotInstanceLinkedComponent(address component);
     error ErrorComponentServiceSenderNotRegistered(address sender);
     error ErrorComponentServiceNotComponent(address component);
@@ -56,9 +58,9 @@ interface IComponentService is
         NftId nftId, 
         string feeName, 
         UFixed previousFractionalFee, 
-        uint256 previousFixedFee,
+        Amount previousFixedFee,
         UFixed newFractionalFee, 
-        uint256 newFixedFee
+        Amount newFixedFee
     );
     
     //-------- component ----------------------------------------------------//
@@ -85,7 +87,7 @@ interface IComponentService is
     //-------- product ------------------------------------------------------//
 
     /// @dev Registers the specified product component for the instance (sender)
-    function registerProduct(address product) external returns (NftId productNftId);
+    function registerProduct(address product, address token) external returns (NftId productNftId);
 
     function setProductFees(
         Fee memory productFee, // product fee on net premium

package/contracts/shared/InstanceLinkedComponent.sol

@@ -71,7 +71,6 @@ abstract contract InstanceLinkedComponent is
         address registry,
         NftId parentNftId,
         string memory name,
-        address token,
         ObjectType componentType,
         IAuthorization authorization,
         bool isInterceptor,
@@ -99,7 +98,6 @@ abstract contract InstanceLinkedComponent is
             registry, 
             parentNftId, 
             name, 
-            token,
             componentType, 
             isInterceptor, 
             initialOwner, 

package/contracts/staking/IStaking.sol

@@ -24,6 +24,7 @@ interface IStaking is
     // target parameters
     event LogStakingLockingPeriodSet(NftId targetNftId, Seconds oldLockingPeriod, Seconds lockingPeriod);
     event LogStakingRewardRateSet(NftId targetNftId, UFixed oldRewardRate, UFixed rewardRate);
+    event LogStakingMaxStakedAmountSet(NftId targetNftId, Amount maxStakedAmount);
 
     // modifiers
     error ErrorStakingNotStake(NftId stakeNftId);
@@ -53,19 +54,25 @@ interface IStaking is
     error ErrorStakingRewardRateTooHigh(NftId targetNftId, UFixed maxRewardRate, UFixed rewardRate);
     error ErrorStakingTargetNotFound(NftId targetNftId);
     error ErrorStakingTargetTokenNotFound(NftId targetNftId, uint256 chainId, address token);
+    error ErrorStakingTargetMaxStakedAmountExceeded(NftId targetNftId, Amount maxStakedAmount, Amount stakedAmount);
 
     error ErrorStakingStakeAmountZero(NftId targetNftId);
 
     // info for individual stake
     struct StakeInfo {
+        // slot 0
         Timestamp lockedUntil;
     }
 
     struct TargetInfo {
+        // Slot 0
+        UFixed rewardRate;
+        Amount maxStakedAmount;
+        // Slot 1
         ObjectType objectType;
-        uint256 chainId;
         Seconds lockingPeriod;
-        UFixed rewardRate;
+        // Slot 2
+        uint256 chainId;
     }
 
     function initializeTokenHandler() external;
@@ -98,6 +105,10 @@ interface IStaking is
     /// permissioned: only the staking service may call this function
     function setRewardRate(NftId targetNftId, UFixed rewardRate) external;
 
+    /// @dev set the maximum staked amount for the specified target.
+    /// permissioned: only the staking service may call this function
+    function setMaxStakedAmount(NftId targetNftId, Amount maxStakedAmount) 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);

package/contracts/staking/IStakingService.sol

@@ -74,6 +74,10 @@ interface IStakingService is IService
     /// Permissioned: Only owner of the specified target.
     function setInstanceRewardRate(NftId instanceNftId, UFixed rewardRate) external;
 
+    /// @dev Set the instance max staked amount to the specified value.
+    /// Permissioned: Only owner of the specified target.
+    function setInstanceMaxStakedAmount(NftId instanceNftId, Amount maxStakingAmount) external;
+
     /// @dev (Re)fills the staking reward reserves for the specified target using the dips provided by the reward provider.
     /// unpermissioned: anybody may fill up staking reward reserves
     function refillInstanceRewardReserves(NftId instanceNftId, address rewardProvider, Amount dipAmount) external returns (Amount newBalance);

package/contracts/staking/Staking.sol

@@ -70,10 +70,11 @@ contract Staking is
         }
 
         StakingStorage storage $ = _getStakingStorage();
+        address dipToken = _getStakingStorage()._tokenRegistry.getDipTokenAddress();
         $._tokenHandler = TokenHandlerDeployerLib.deployTokenHandler(
             address(getRegistry()),
             address(this),
-            address(getToken()), 
+            dipToken, 
             getRegistry().getAuthority());
     }
 
@@ -146,7 +147,8 @@ contract Staking is
                 objectType: expectedObjectType,
                 chainId: chainId,
                 lockingPeriod: initialLockingPeriod,
-                rewardRate: initialRewardRate}));
+                rewardRate: initialRewardRate,
+                maxStakedAmount: AmountLib.max()}));
     }
 
 
@@ -194,6 +196,21 @@ contract Staking is
         emit LogStakingRewardRateSet(targetNftId, oldRewardRate, rewardRate);
     }
 
+    function setMaxStakedAmount(NftId targetNftId, Amount maxStakedAmount)
+        external
+        virtual
+        restricted()
+        onlyTarget(targetNftId)
+    {
+        IStaking.TargetInfo memory targetInfo = getStakingReader().getTargetInfo(targetNftId);
+
+        targetInfo.maxStakedAmount = maxStakedAmount;
+        
+        _getStakingStorage()._store.updateTarget(targetNftId, targetInfo);
+
+        emit LogStakingMaxStakedAmountSet(targetNftId, maxStakedAmount);
+    }
+
 
     function refillRewardReserves(NftId targetNftId, Amount dipAmount)
         external
@@ -511,7 +528,6 @@ contract Staking is
             registryAddress, 
             registry.getNftId(), // parent nft id
             CONTRACT_NAME,
-            dipTokenAddress,
             STAKING(), 
             false, // is interceptor
             stakingOwner, 

package/contracts/staking/StakingLib.sol

@@ -46,6 +46,11 @@ library StakingLib {
         // TODO check that additional dip, rewards and rewards increment 
         // are still ok with max target staking amount
         NftId targetNftId = registry.getParentNftId(stakeNftId);
+        Amount maxStakedAmount = stakingReader.getTargetMaxStakedAmount(targetNftId);
+
+        if (stakeBalance > maxStakedAmount) {
+            revert IStaking.ErrorStakingTargetMaxStakedAmountExceeded(targetNftId, maxStakedAmount, stakeBalance);
+        }
 
         stakingStore.restakeRewards(
             stakeNftId, 
@@ -211,14 +216,17 @@ library StakingLib {
         Amount dipAmount
     )
         public 
-        pure 
+        view 
     {
         // check stake amount > 0
         if (dipAmount.eqz()) {
             revert IStaking.ErrorStakingStakeAmountZero(targetNftId);
         }
 
-        // TODO add check for target specific max dip amount (min stake + tvl * stake rate + buffer)
+        Amount maxStakedAmount = stakingReader.getTargetMaxStakedAmount(targetNftId);
+        if (dipAmount > maxStakedAmount) {
+            revert IStaking.ErrorStakingTargetMaxStakedAmountExceeded(targetNftId, maxStakedAmount, dipAmount);
+        }
     }
 
     function calculateRewardIncrease(

package/contracts/staking/StakingReader.sol

@@ -104,6 +104,11 @@ contract StakingReader is
         rewardRate = getTargetInfo(targetNftId).rewardRate;
     }
 
+    /// @dev get the max staked amount allowed for the specified target nft id.
+    function getTargetMaxStakedAmount(NftId targetNftId) external view returns (Amount maxStakedAmount) {
+        return getTargetInfo(targetNftId).maxStakedAmount;
+    }
+
 
     /// @dev get the reward rate for the specified target nft id.
     function getRewardRate(NftId targetNftId) external view returns (UFixed rewardRate) {

package/contracts/staking/StakingService.sol

@@ -98,6 +98,17 @@ contract StakingService is
             rewardRate);
     }
 
+    function setInstanceMaxStakedAmount(NftId instanceNftId, Amount maxStakingAmount)
+        external
+        virtual
+        restricted()
+    {
+        _checkNftType(instanceNftId, INSTANCE());
+        _getStakingServiceStorage()._staking.setMaxStakedAmount(
+            instanceNftId, 
+            maxStakingAmount);
+    }
+
 
     function refillInstanceRewardReserves(NftId instanceNftId, address rewardProvider, Amount dipAmount)
         external

package/contracts/staking/StakingStore.sol

@@ -91,7 +91,8 @@ contract StakingStore is
                 objectType: PROTOCOL(),
                 chainId: 1,
                 lockingPeriod: TargetManagerLib.getDefaultLockingPeriod(),
-                rewardRate: TargetManagerLib.getDefaultRewardRate()}));
+                rewardRate: TargetManagerLib.getDefaultRewardRate(),
+                maxStakedAmount: AmountLib.max()}));
     }
 
 

package/contracts/type/Fee.sol

@@ -5,16 +5,16 @@ import {Amount, AmountLib} from "./Amount.sol";
 import {UFixed, UFixedLib} from "./UFixed.sol";
 
 struct Fee {
+    // slot 0
     UFixed fractionalFee;
-    // TODO migrate fixed fee to Amount
-    uint256 fixedFee;
+    Amount fixedFee;
 }
 
 library FeeLib {
 
     /// @dev Return a zero fee struct (0, 0)
     function zero() public pure returns (Fee memory fee) {
-        return Fee(UFixed.wrap(0), 0);
+        return Fee(UFixed.wrap(0), AmountLib.zero());
     }
 
     /// @dev Converts the uint256 to a fee struct.
@@ -22,7 +22,7 @@ library FeeLib {
         UFixed fractionalFee,
         uint256 fixedFee
     ) public pure returns (Fee memory fee) {
-        return Fee(fractionalFee, fixedFee);
+        return Fee(fractionalFee, AmountLib.toAmount(fixedFee));
     }
 
     /// @dev Calculates fee and net amounts for the provided parameters
@@ -41,14 +41,14 @@ library FeeLib {
         if(gtz(fee)) {
             UFixed fractionalAmount = 
                 amount.toUFixed() * fee.fractionalFee;
-            feeAmount = AmountLib.toAmount(fractionalAmount.toInt() + fee.fixedFee);
+            feeAmount = AmountLib.toAmount(fractionalAmount.toInt()) + fee.fixedFee;
             netAmount = netAmount - feeAmount;
         }
     }
 
     /// @dev Return the percent fee struct (x%, 0)
     function percentageFee(uint8 percent) public pure returns (Fee memory fee) {
-        return Fee(UFixedLib.toUFixed(percent, -2), 0);
+        return Fee(UFixedLib.toUFixed(percent, -2), AmountLib.zero());
     }
 
     // pure free functions for operators
@@ -57,10 +57,10 @@ library FeeLib {
     }
 
     function gtz(Fee memory fee) public pure returns (bool) {
-        return UFixed.unwrap(fee.fractionalFee) > 0 || fee.fixedFee > 0;
+        return UFixed.unwrap(fee.fractionalFee) > 0 || fee.fixedFee.gtz();
     }
 
     function eqz(Fee memory fee) public pure returns (bool) {
-        return fee.fixedFee == 0 && UFixed.unwrap(fee.fractionalFee) == 0;
+        return fee.fixedFee.eqz() && UFixed.unwrap(fee.fractionalFee) == 0;
     }
 }