@pru.pinya/contracts 1.0.0

package/contracts/libs/EnumerableSetUint.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.0;
+
+library EnumerableSetUint {
+    struct UintSet {
+        uint256[] _values;
+        mapping(uint256 => uint256) _indexes;
+    }
+
+    function add(UintSet storage set, uint256 value) internal returns (bool) {
+        if (!contains(set, value)) {
+            set._values.push(value);
+            set._indexes[value] = set._values.length;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function remove(UintSet storage set, uint256 value) internal returns (bool) {
+        uint256 valueIndex = set._indexes[value];
+        if (valueIndex != 0) {
+            uint256 toDeleteIndex = valueIndex - 1;
+            uint256 lastIndex = set._values.length - 1;
+            uint256 lastvalue = set._values[lastIndex];
+            set._values[toDeleteIndex] = lastvalue;
+            set._indexes[lastvalue] = toDeleteIndex + 1;
+            set._values.pop();
+            delete set._indexes[value];
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
+        return set._indexes[value] != 0;
+    }
+
+    function length(UintSet storage set) internal view returns (uint256) {
+        return set._values.length;
+    }
+
+    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
+        require(set._values.length > index, "EnumerableSet: index out of bounds");
+        return set._values[index];
+    }
+
+    function getAll(UintSet storage set) internal view returns (uint256[] memory) {
+        return set._values;
+    }
+
+    function get(
+        UintSet storage set,
+        uint256 _page,
+        uint256 _limit
+    ) internal view returns (uint256[] memory) {
+        require(_page > 0 && _limit > 0);
+        uint256 tempLength = _limit;
+        uint256 cursor = (_page - 1) * _limit;
+        uint256 _uintLength = length(set);
+        if (cursor >= _uintLength) {
+            return new uint256[](0);
+        }
+        if (tempLength > _uintLength - cursor) {
+            tempLength = _uintLength - cursor;
+        }
+        uint256[] memory uintList = new uint256[](tempLength);
+        for (uint256 i = 0; i < tempLength; i++) {
+            uintList[i] = at(set, cursor + i);
+        }
+        return uintList;
+    }
+}

package/contracts/libs/EnumerateMap.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.0;
+
+library EnumerableMap {
+    struct MapEntry {
+        bytes32 _key;
+        bytes32 _value;
+    }
+
+    struct Map {
+        MapEntry[] _entries;
+        mapping(bytes32 => uint256) _indexes;
+    }
+
+    function _set(
+        Map storage map,
+        bytes32 key,
+        bytes32 value
+    ) private returns (bool) {
+        uint256 keyIndex = map._indexes[key];
+
+        if (keyIndex == 0) {
+            map._entries.push(MapEntry({ _key: key, _value: value }));
+            map._indexes[key] = map._entries.length;
+            return true;
+        } else {
+            map._entries[keyIndex - 1]._value = value;
+            return false;
+        }
+    }
+
+    function _remove(Map storage map, bytes32 key) private returns (bool) {
+        uint256 keyIndex = map._indexes[key];
+
+        if (keyIndex != 0) {
+            uint256 toDeleteIndex = keyIndex - 1;
+            uint256 lastIndex = map._entries.length - 1;
+
+            MapEntry storage lastEntry = map._entries[lastIndex];
+
+            map._entries[toDeleteIndex] = lastEntry;
+            map._indexes[lastEntry._key] = toDeleteIndex + 1;
+
+            map._entries.pop();
+
+            delete map._indexes[key];
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function _contains(Map storage map, bytes32 key) private view returns (bool) {
+        return map._indexes[key] != 0;
+    }
+
+    function _length(Map storage map) private view returns (uint256) {
+        return map._entries.length;
+    }
+
+    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
+        require(map._entries.length > index, "EnumerableMap: index out of bounds");
+
+        MapEntry storage entry = map._entries[index];
+        return (entry._key, entry._value);
+    }
+
+    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
+        uint256 keyIndex = map._indexes[key];
+        if (keyIndex == 0) return (false, 0);
+        return (true, map._entries[keyIndex - 1]._value);
+    }
+
+    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
+        uint256 keyIndex = map._indexes[key];
+        require(keyIndex != 0, "EnumerableMap: nonexistent key");
+        return map._entries[keyIndex - 1]._value;
+    }
+
+    function _get(
+        Map storage map,
+        bytes32 key,
+        string memory errorMessage
+    ) private view returns (bytes32) {
+        uint256 keyIndex = map._indexes[key];
+        require(keyIndex != 0, errorMessage);
+        return map._entries[keyIndex - 1]._value;
+    }
+
+    struct UintToAddressMap {
+        Map _inner;
+    }
+
+    function set(
+        UintToAddressMap storage map,
+        uint256 key,
+        address value
+    ) internal returns (bool) {
+        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
+    }
+
+    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
+        return _remove(map._inner, bytes32(key));
+    }
+
+    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
+        return _contains(map._inner, bytes32(key));
+    }
+
+    function length(UintToAddressMap storage map) internal view returns (uint256) {
+        return _length(map._inner);
+    }
+
+    function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
+        (bytes32 key, bytes32 value) = _at(map._inner, index);
+        return (uint256(key), address(uint160(uint256(value))));
+    }
+
+    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
+        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
+        return (success, address(uint160(uint256(value))));
+    }
+
+    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
+        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
+    }
+
+    function get(
+        UintToAddressMap storage map,
+        uint256 key,
+        string memory errorMessage
+    ) internal view returns (address) {
+        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
+    }
+}

package/contracts/libs/String.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+library Strings {
+    function toString(uint256 value) internal pure returns (string memory) {
+        // Inspired by OraclizeAPI's implementation - MIT licence
+        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
+
+        if (value == 0) {
+            return "0";
+        }
+        uint256 temp = value;
+        uint256 digits;
+        while (temp != 0) {
+            digits++;
+            temp /= 10;
+        }
+        bytes memory buffer = new bytes(digits);
+        while (value != 0) {
+            digits -= 1;
+            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
+            value /= 10;
+        }
+        return string(buffer);
+    }
+}