@etherisc/gif-next 0.0.2-a67250d-285 → 0.0.2-a6a9eeb-432

package/contracts/staking/TargetHandler.sol

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+import {IRegistry} from "../registry/IRegistry.sol";
+import {ITargetLimitHandler} from "./ITargetLimitHandler.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
+import {NftId} from "../type/NftId.sol";
+import {StakingStore} from "./StakingStore.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
+
+
+contract TargetHandler is
+    Initializable,
+    AccessManaged,
+    ITargetLimitHandler
+{
+
+    event LogTargetHandlerUpdateTriggersSet(uint16 tvlUpdatesTrigger, UFixed minTvlRatioTrigger, Blocknumber lastUpdateIn);
+
+    IRegistry private _registry;
+    StakingStore private _store;
+
+    /// @dev Update trigger value: Number of TVL updates below which limit updates are suppressed
+    uint16 private _tvlUpdatesTrigger; 
+    /// @dev Maximum TVL ratio: Any ratio above this value will trigger a limit update
+    UFixed private _minTvlRatioTrigger;
+    Blocknumber private _lastUpdateIn;
+
+
+    constructor (
+        IRegistry registry,
+        StakingStore stakingStore
+    )
+        AccessManaged(msg.sender)
+    {
+        // set final authority and registry
+        setAuthority(registry.getAuthority());
+        _registry = registry;
+        _store = stakingStore;
+
+        // set default trigger values
+        _setUpdateTriggers(
+            10, // check after 2 TVL updates
+            UFixedLib.toUFixed(1, -1)); // 10% deviation from baseline TVL
+    }
+
+
+    // TODO do we really need this?
+    // if so: add onlyDeployer (new base contract? also for reader)
+    // if not: remove oz intializer/initializable
+    function initialize()
+        external
+        initializer()
+    { }
+
+    //--- staking functions -------------------------------------------------------//
+
+    /// @dev Sets the TVL update triggers.
+    function setUpdateTriggers(
+        uint16 tvlUpdatesTrigger,
+        UFixed minTvlRatioTrigger
+    )
+        external
+        restricted()
+    {
+        _setUpdateTriggers(tvlUpdatesTrigger, minTvlRatioTrigger);
+    }
+
+    //--- ITargetLimitHandler -----------------------------------------------------//
+
+    /// @inheritdoc ITargetLimitHandler
+    // Current implementation only considers the TVL amounts. 
+    // Future implementations may also consider target or token specific factors. 
+    function isLimitUpdateRequired(
+        NftId, // targetNftId
+        address , // token
+        uint16 tvlUpdatesCount,
+        Amount baselineTvlAmount, 
+        Amount currentTvlAmount
+    )
+        external 
+        virtual
+        view
+        returns (bool updateIsRequired)
+    {
+        // no update required if below the TVL updates trigger
+        if (tvlUpdatesCount < _tvlUpdatesTrigger) {
+            return false;
+        }
+
+        // no update required if both amounts are zero
+        Amount zero = AmountLib.zero();
+        if (baselineTvlAmount == zero && currentTvlAmount == zero) {
+            return false;
+
+        // update required if one amount is zero
+        } else if (baselineTvlAmount == zero || currentTvlAmount == zero) {
+            return true;
+        }
+
+        // calculate the ratio of the current TVL amount to the baseline TVL amount
+        UFixed baseline = baselineTvlAmount.toUFixed();
+        UFixed current = currentTvlAmount.toUFixed();
+        UFixed ratio;
+
+        if (baseline > current) { ratio = baseline / current; }
+        else { ratio = current / baseline; }
+
+        // update required if the ratio is above the maximum TVL ratio
+        return ratio >= _minTvlRatioTrigger;
+    }
+
+
+    function _setUpdateTriggers(
+        uint16 tvlUpdatesTrigger,
+        UFixed minTvlRatioTrigger
+    )
+        internal
+    {
+        Blocknumber lastUpdateIn = _lastUpdateIn;
+        _tvlUpdatesTrigger = tvlUpdatesTrigger;
+        _minTvlRatioTrigger = minTvlRatioTrigger;
+        _lastUpdateIn = BlocknumberLib.current();
+
+        emit LogTargetHandlerUpdateTriggersSet(tvlUpdatesTrigger, minTvlRatioTrigger, lastUpdateIn);
+    }
+}

package/contracts/staking/TargetManagerLib.sol

@@ -3,8 +3,10 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
+import {IStaking} from "./IStaking.sol";
+
 import {Amount, AmountLib} from "../type/Amount.sol";
-import {Component} from "../shared/Component.sol";
+import {ChainIdLib} from "../type/ChainId.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
 import {IStaking} from "./IStaking.sol";
@@ -37,7 +39,8 @@ library TargetManagerLib {
             revert IStaking.ErrorStakingTargetNotFound(targetNftId);
         }
 
-        checkLockingPeriod(targetNftId, lockingPeriod);
+        ObjectType targetType = reader.getTargetInfo(targetNftId).objectType;
+        checkLockingPeriod(reader, targetNftId, targetType, lockingPeriod);
 
         targetInfo = reader.getTargetInfo(targetNftId);
         oldLockingPeriod = targetInfo.lockingPeriod;
@@ -65,7 +68,8 @@ library TargetManagerLib {
             revert IStaking.ErrorStakingTargetNotFound(targetNftId);
         }
 
-        checkRewardRate(targetNftId, rewardRate);
+        ObjectType targetType = reader.getTargetInfo(targetNftId).objectType;
+        checkRewardRate(reader, targetNftId, targetType, rewardRate);
 
         targetInfo = reader.getTargetInfo(targetNftId);
         oldRewardRate = targetInfo.rewardRate;
@@ -79,8 +83,8 @@ library TargetManagerLib {
         StakingReader stakingReader,
         NftId targetNftId,
         ObjectType expectedObjectType,
-        Seconds initialLockingPeriod,
-        UFixed initialRewardRate
+        Seconds lockingPeriod,
+        UFixed rewardRate
     )
         external
         view
@@ -95,63 +99,54 @@ library TargetManagerLib {
             revert IStaking.ErrorStakingTargetAlreadyRegistered(targetNftId);
         }
 
-        // target object type must be allowed
-        if (!isTargetTypeSupported(expectedObjectType)) {
+        // get setup info for additional checks
+        IStaking.SupportInfo memory supportInfo = stakingReader.getSupportInfo(expectedObjectType);
+
+        // check if type is supported and new targets of that type are allowed
+        if (!(supportInfo.isSupported && supportInfo.allowNewTargets)) {
             revert IStaking.ErrorStakingTargetTypeNotSupported(targetNftId, expectedObjectType);
         }
 
-        checkLockingPeriod(targetNftId, initialLockingPeriod);
-        checkRewardRate(targetNftId, initialRewardRate);
+        // check if cross chain targets are allowed (if applicable)
+        bool isCurrentChain = ChainIdLib.isCurrentChain(targetNftId);
+        if (!supportInfo.allowCrossChain && !isCurrentChain) {
+            revert IStaking.ErrorStakingCrossChainTargetsNotSupported(targetNftId, expectedObjectType);
+        }
 
-        // target nft id must be known and registered with the expected object type
-        if (!registry.isRegistered(targetNftId)) {
-            revert IStaking.ErrorStakingTargetNotFound(targetNftId);
-        } else {
-            // check that expected object type matches with registered object type
-            ObjectType actualObjectType = registry.getObjectInfo(targetNftId).objectType;
-            if (actualObjectType != expectedObjectType) {
-                revert IStaking.ErrorStakingTargetUnexpectedObjectType(targetNftId, expectedObjectType, actualObjectType);
+        // additional check for current chain target: target nft id must be known and registered with the expected object type
+        if (isCurrentChain) {
+            if (!registry.isRegistered(targetNftId)) {
+                revert IStaking.ErrorStakingTargetNotFound(targetNftId);
+            } else {
+                // check that expected object type matches with registered object type
+                ObjectType actualObjectType = registry.getObjectInfo(targetNftId).objectType;
+                if (actualObjectType != expectedObjectType) {
+                    revert IStaking.ErrorStakingTargetUnexpectedObjectType(targetNftId, expectedObjectType, actualObjectType);
+                }
             }
         }
-    }
 
-
-    function isTargetTypeSupported(ObjectType objectType)
-        public 
-        pure 
-        returns (bool isSupported)
-    {
-        if(objectType == PROTOCOL()) { return true; }
-        if(objectType == INSTANCE()) { return true; }
-
-        return false;
+        // check locking period and reward rate
+        _checkLockingPeriod(targetNftId, lockingPeriod, supportInfo);
+        _checkRewardRate(targetNftId, rewardRate, supportInfo);
     }
 
 
-    function checkLockingPeriod(NftId targetNftId, Seconds lockingPeriod)
+    function checkLockingPeriod(StakingReader reader, NftId targetNftId, ObjectType targetType, Seconds lockingPeriod)
         public 
-        pure
+        view
     {
-        // check locking period is >= min locking period
-        if (lockingPeriod.lt(getMinimumLockingPeriod())) {
-            revert IStaking.ErrorStakingLockingPeriodTooShort(targetNftId, getMinimumLockingPeriod(), lockingPeriod);
-        }
-
-        // check locking period <= max locking period
-        if (lockingPeriod > getMaxLockingPeriod()) {
-            revert IStaking.ErrorStakingLockingPeriodTooLong(targetNftId, getMaxLockingPeriod(), lockingPeriod);
-        }
+        IStaking.SupportInfo memory supportInfo = reader.getSupportInfo(targetType);
+        _checkLockingPeriod(targetNftId, lockingPeriod, supportInfo);
     }
 
 
-    function checkRewardRate(NftId targetNftId, UFixed rewardRate)
+    function checkRewardRate(StakingReader reader, NftId targetNftId, ObjectType targetType, UFixed rewardRate)
         public
-        pure
+        view
     {
-        // check reward rate <= max reward rate
-        if (rewardRate > getMaxRewardRate()) {
-            revert IStaking.ErrorStakingRewardRateTooHigh(targetNftId, getMaxRewardRate(), rewardRate);
-        }
+        IStaking.SupportInfo memory supportInfo = reader.getSupportInfo(targetType);
+        _checkRewardRate(targetNftId, rewardRate, supportInfo);
     }
 
 
@@ -160,7 +155,7 @@ library TargetManagerLib {
         UFixed stakingRate
     )
         public
-        view
+        pure
         returns (Amount dipAmount)
     {
         dipAmount = tokenAmount.multiplyWith(stakingRate);
@@ -208,4 +203,32 @@ library TargetManagerLib {
     function toTargetKey(NftId targetNftId) public pure returns (Key32 targetKey) {
         return targetNftId.toKey32(TARGET());
     }
+
+
+    function _checkLockingPeriod(NftId targetNftId, Seconds lockingPeriod, IStaking.SupportInfo memory supportInfo)
+        private
+        pure
+    {
+        if (lockingPeriod < supportInfo.minLockingPeriod || lockingPeriod > supportInfo.maxLockingPeriod) {
+            revert IStaking.ErrorStakingLockingPeriodInvalid(
+                targetNftId, 
+                lockingPeriod, 
+                supportInfo.minLockingPeriod,
+                supportInfo.maxLockingPeriod);
+        }
+    }
+
+
+    function _checkRewardRate(NftId targetNftId, UFixed rewardRate, IStaking.SupportInfo memory supportInfo) 
+        private
+        pure
+    {
+        if (rewardRate < supportInfo.minRewardRate || rewardRate > supportInfo.maxRewardRate) {
+            revert IStaking.ErrorStakingRewardRateInvalid(
+                targetNftId, 
+                rewardRate,
+                supportInfo.minRewardRate,
+                supportInfo.maxRewardRate);
+        }
+    }
 }

package/contracts/type/Amount.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.8.20;
 
 import {UFixed, UFixedLib} from "./UFixed.sol";
 
+/// @dev Targets: 100 trillion (worlds GDP) with 6 decimal places
+/// 3 trillion USD (total crypto market cap) with 12 decimal places.
+/// 2023 100 trillion USD => 100e12 * 1e6 = 1e20
+/// 2024 2 trillion crypto market cap => 2e12 * 1e18 = 2e30
 type Amount is uint96;
 
 using {
@@ -11,7 +15,9 @@ using {
     eqAmount as ==,
     nqAmount as !=,
     ltAmount as <,
+    ltAmount as <=,
     gtAmount as >,
+    gteAmount as >=,
     AmountLib.add,
     AmountLib.eq,
     AmountLib.eqz,
@@ -43,10 +49,18 @@ function ltAmount(Amount a, Amount b) pure returns (bool) {
     return AmountLib.lt(a, b);
 }
 
+function lteAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.lte(a, b);
+}
+
 function gtAmount(Amount a, Amount b) pure returns (bool) {
     return AmountLib.gt(a, b);
 }
 
+function gteAmount(Amount a, Amount b) pure returns (bool) {
+    return AmountLib.gte(a, b);
+}
+
 library AmountLib {
 
     error ErrorAmountLibValueTooBig(uint256 amount);
@@ -84,6 +98,11 @@ library AmountLib {
         return Amount.unwrap(a1) < Amount.unwrap(a2);
     }
 
+    /// @dev return true if amount a1 is less or equal than a2
+    function lte(Amount a1, Amount a2) public pure returns (bool) {
+        return Amount.unwrap(a1) <= Amount.unwrap(a2);
+    }
+
     /// @dev return true if amount a1 is greater than a2
     function gt(Amount a1, Amount a2) public pure returns (bool) {
         return Amount.unwrap(a1) > Amount.unwrap(a2);

package/contracts/type/Blocknumber.sol

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-type Blocknumber is uint32;
+/// @dev Target: Cover 10 years with 1 ms block times.
+/// Typical block times are a few seconds.
+type Blocknumber is uint40;
 
 using {
     gtBlocknumber as >,
@@ -56,25 +58,23 @@ function toBlocknumber(uint256 blocknum) pure returns (Blocknumber) {
     return Blocknumber.wrap(uint32(blocknum));
 }
 
-function blockBlocknumber() view returns (Blocknumber) {
-    return BlocknumberLib.currentBlocknumber();
-}
-
-// TODO move to BlocknumberLib and rename to zero()
-/// @dev Return the Blocknumber zero (0)
-function zeroBlocknumber() pure returns (Blocknumber) {
-    return toBlocknumber(0);
-}
-
 /// @dev Return the current block number
 function blockNumber() view returns (Blocknumber) {
     return toBlocknumber(block.number);
 }
 
 library BlocknumberLib {
-    /// @dev returns the current Blocknumber
-    function currentBlocknumber() public view returns (Blocknumber) {
-        return Blocknumber.wrap(uint32(block.number));
+
+    function zero() public pure returns (Blocknumber) {
+        return Blocknumber.wrap(0);
+    }
+
+    function max() public pure returns (Blocknumber) {
+        return Blocknumber.wrap(type(uint40).max);
+    }
+
+    function current() public view returns (Blocknumber) {
+        return Blocknumber.wrap(uint40(block.number));
     }
 
     /// @dev return true iff blocknumber is 0
@@ -82,7 +82,7 @@ library BlocknumberLib {
         return Blocknumber.unwrap(blocknumber) == 0;
     }
 
-    /// @dev return true iff blocknumber is 0
+    /// @dev return true iff blocknumber is > 0
     function gtz(Blocknumber blocknumber) public pure returns (bool) {
         return Blocknumber.unwrap(blocknumber) > 0;
     }

package/contracts/type/ChainId.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {NftId} from "./NftId.sol";
+
+/// @dev Target: Cover chain IDs up to 26 decimal places.
+/// Current longest chain ID seems to be DCHAIN Testnet: 2713017997578000 with 16 decimal places 
+type ChainId is uint96;
+
+using {
+    eqChainId as ==,
+    neChainId as !=,
+    ChainIdLib.toInt,
+    ChainIdLib.eqz,
+    ChainIdLib.gtz
+} for ChainId global;
+
+
+/// @dev return true if ChainId a is equal to ChainId b
+function eqChainId(ChainId a, ChainId b) pure returns (bool) {
+    return ChainId.unwrap(a) == ChainId.unwrap(b);
+}
+
+/// @dev return true if ChainId a is not equal to ChainId b
+function neChainId(ChainId a, ChainId b) pure returns (bool) {
+    return ChainId.unwrap(a) != ChainId.unwrap(b);
+}
+
+
+library ChainIdLib {
+
+    error ErrorChainIdLibValueTooBig(uint256 chainId);
+
+
+    function zero() public pure returns (ChainId) {
+        return ChainId.wrap(0);
+    }
+
+
+    function max() public pure returns (ChainId) {
+        return ChainId.wrap(_max());
+    }
+
+
+    function current() public view returns (ChainId) {
+        return toChainId(block.chainid);
+    }
+
+
+    /// @dev return true iff chainId is 0
+    function eqz(ChainId chainId) public pure returns (bool) {
+        return ChainId.unwrap(chainId) == 0;
+    }
+
+
+    /// @dev return true iff chainId is > 0
+    function gtz(ChainId chainId) public pure returns (bool) {
+        return ChainId.unwrap(chainId) > 0;
+    }
+
+
+    /// @dev converts the uint into ChainId
+    /// function reverts if value is exceeding max ChainId value
+    function toChainId(uint256 chainId) public pure returns (ChainId) {
+        if(chainId > _max()) {
+            revert ErrorChainIdLibValueTooBig(chainId);
+        }
+
+        return ChainId.wrap(uint96(chainId));
+    }
+
+
+    /// @dev returns true iff NFT ID is from the current chain.
+    function isCurrentChain(NftId nftId) public view returns (bool) {
+        return _fromNftId(nftId) == block.chainid;
+    }
+
+
+    function fromNftId(NftId nftId) public pure returns (ChainId) {
+        return toChainId(_fromNftId(nftId));
+    }
+
+
+    /// @dev converts the ChainId to a uint256
+    function toInt(ChainId chainId) public pure returns (uint256) {
+        return uint256(uint96(ChainId.unwrap(chainId)));
+    }
+
+
+    function _fromNftId(NftId nftId) internal pure returns (uint256 chainIdInt) {
+        uint256 nftIdInt = nftId.toInt();
+        uint256 chainIdDigits = nftIdInt % 100; // Extract the last two digits
+        chainIdInt = nftIdInt % 10**(chainIdDigits + 2) / 100; // Extract the chainId
+    }
+
+
+    function _max() internal pure returns (uint96) {
+        // IMPORTANT: type nees to match with actual definition for Amount
+        return type(uint96).max;
+    }
+}

package/contracts/type/ClaimId.sol

@@ -12,6 +12,7 @@ import {NftId} from "./NftId.sol";
 using {
     eqClaimId as ==, 
     neClaimId as !=, 
+    ClaimIdLib.eq,
     ClaimIdLib.eqz,
     ClaimIdLib.gtz,
     ClaimIdLib.toInt,
@@ -21,7 +22,7 @@ using {
 
 // pure free functions for operators
 function eqClaimId(ClaimId a, ClaimId b) pure returns (bool isSame) {
-    return ClaimId.unwrap(a) == ClaimId.unwrap(b);
+    return ClaimIdLib.eq(a, b);
 }
 
 function neClaimId(ClaimId a, ClaimId b) pure returns (bool isDifferent) {
@@ -68,6 +69,10 @@ library ClaimIdLib {
         return ClaimId.unwrap(a) > 0;
     }
 
+    function eq(ClaimId a, ClaimId b) public pure returns (bool) {
+        return ClaimId.unwrap(a) == ClaimId.unwrap(b);
+    }
+
     /// @dev Returns true if the value is zero (== 0).
     function eqz(ClaimId a) public pure returns (bool) {
         return ClaimId.unwrap(a) == 0;

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;
     }
 }

package/contracts/type/Key32.sol

@@ -28,8 +28,8 @@ library Key32Lib {
 
     uint8 public constant TYPE_SHIFT = 31 * 8;
     uint8 public constant ID_SHIFT = uint8(32 * 8 - TYPE_SHIFT);
-    bytes32 public constant TYPE_MASK = bytes32(bytes1(type(uint8).max)); // first byte in bytes32
-    bytes32 public constant ID_MASK = bytes32(~TYPE_MASK); // remaining bytes in bytes32
+    bytes32 public constant TYPE_MASK = bytes32(bytes1(type(uint8).max)); // [32] byte in bytes32
+    bytes32 public constant ID_MASK = bytes32(~TYPE_MASK); // [0..31] bytes in bytes32
 
     function toKey32(ObjectType objectType, KeyId id) public pure returns (Key32) {
         uint256 uintObjectType = ObjectType.unwrap(objectType);

package/contracts/type/Key32Set.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Key32} from "../type/Key32.sol";
+
+// based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/structs/EnumerableSet.sol
+library LibKey32Set {
+
+    struct Set {
+        Key32[] keys;
+        mapping(Key32 key => uint256 index) at;
+    }
+
+    error ErrorKey32SetAlreadyAdded(Key32 key);
+    error ErrorKey32SetNotInSet(Key32 key);
+
+
+    function add(Set storage set, Key32 key) external {
+        if (set.at[key] > 0) {
+            revert ErrorKey32SetAlreadyAdded(key);
+        }
+
+        set.keys.push(key);
+        set.at[key] = set.keys.length;
+    }
+
+    function remove(Set storage set, Key32 key) external {
+        uint256 nftIdIndex = set.at[key];
+
+        if (nftIdIndex == 0) {
+            revert ErrorKey32SetNotInSet(key);
+        }
+
+        uint256 toDeleteIndex = nftIdIndex - 1;
+        uint256 lastIndex = set.keys.length - 1;
+
+        if (lastIndex != toDeleteIndex) {
+            Key32 lastId = set.keys[lastIndex];
+            set.keys[toDeleteIndex] = lastId;
+            set.at[lastId] = nftIdIndex; // Replace lastValue's index to valueIndex
+        }
+
+        set.keys.pop();
+        delete set.at[key];
+    }
+
+    function isEmpty(Set storage set) external view returns(bool empty) {
+        return set.keys.length == 0;
+    }
+
+    function contains(Set storage set, Key32 key) external view returns(bool inSet) {
+        return set.at[key] > 0;
+    }
+
+    function size(Set storage set) external view returns(uint256 length) {
+        return set.keys.length;
+    }
+
+    function getElementAt(Set storage set, uint256 index) external view returns(Key32 key) {
+        return set.keys[index];
+    }
+}