@etherisc/gif-next 0.0.2-f0d86c2-077 → 0.0.2-f0ebcc7-306

package/contracts/type/String.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ShortString, ShortStrings} from "@openzeppelin/contracts/utils/ShortStrings.sol";
+
+type Str is bytes32;
+
+using {
+    StrEq as ==,
+    StrNe as !=,
+    StrLib.toString,
+    StrLib.length
+} for Str global;
+
+function StrEq(Str s1, Str s2) pure returns (bool) {
+    return StrLib.eq(s1, s2);
+}
+
+function StrNe(Str s1, Str s2) pure returns (bool) {
+    return StrLib.ne(s1, s2);
+}
+
+library StrLib {
+
+
+    /// @dev converts the provided string into a short string.
+    /// uses ShortStrings.toShortString
+    function toStr(string memory str) public pure returns (Str) {
+        return Str.wrap(ShortString.unwrap(ShortStrings.toShortString(str)));
+    }
+
+    /// @dev return true iff s1 equals s2
+    function eq(Str s1, Str s2) public pure returns (bool) {
+        return Str.unwrap(s1) == Str.unwrap(s2);
+    }
+
+    /// @dev return true iff s1 differs from s2
+    function ne(Str s1, Str s2) public pure returns (bool) {
+        return Str.unwrap(s1) != Str.unwrap(s2);
+    }
+
+    /// @dev converts the provided short string into a string.
+    /// uses ShortStrings.toString
+    function toString(Str str) public pure returns (string memory) {
+        return ShortStrings.toString(ShortString.wrap(Str.unwrap(str)));
+    }
+
+    /// @dev converts the provided short string into a string.
+    /// uses ShortStrings.byteLength
+    function length(Str str) public pure returns (uint256 byteLength) {
+        return ShortStrings.byteLength(ShortString.wrap(Str.unwrap(str)));
+    }
+}

package/contracts/{types → type}/Timestamp.sol

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
+
+import {Seconds} from "./Seconds.sol";
 
 type Timestamp is uint40;
 
@@ -10,9 +12,16 @@ using {
     lteTimestamp as <=,
     eqTimestamp as ==,
     neTimestamp as !=,
+    TimestampLib.eq,
+    TimestampLib.ne,
+    TimestampLib.gt,
+    TimestampLib.gte,
+    TimestampLib.lt,
+    TimestampLib.lte,
     TimestampLib.gtz,
     TimestampLib.eqz,
-    TimestampLib.addSeconds
+    TimestampLib.addSeconds,
+    TimestampLib.toInt
 } for Timestamp global;
 
 /// @dev return true if Timestamp a is after Timestamp b
@@ -45,21 +54,30 @@ function neTimestamp(Timestamp a, Timestamp b) pure returns (bool) {
     return Timestamp.unwrap(a) != Timestamp.unwrap(b);
 }
 
-/// @dev Converts the uint256 to a Timestamp.
-function toTimestamp(uint256 timestamp) pure returns (Timestamp) {
-    return Timestamp.wrap(uint40(timestamp));
-}
-
-function blockTimestamp() view returns (Timestamp) {
-    return toTimestamp(block.timestamp);
-}
-
+// TODO move to TimestampLib and rename to zero()
 /// @dev Return the Timestamp zero (0)
 function zeroTimestamp() pure returns (Timestamp) {
-    return toTimestamp(0);
+    return Timestamp.wrap(0);
 }
 
 library TimestampLib {
+
+    function zero() public pure returns (Timestamp) {
+        return Timestamp.wrap(0);
+    }
+
+    function max() public pure returns (Timestamp) {
+        return Timestamp.wrap(type(uint40).max);
+    }
+    
+    function blockTimestamp() public view returns (Timestamp) {
+        return Timestamp.wrap(uint40(block.timestamp));
+    }
+
+    function toTimestamp(uint256 timestamp) public pure returns (Timestamp) {
+        return Timestamp.wrap(uint40(timestamp));
+    }
+    
     /// @dev return true if Timestamp a is after Timestamp b
     function gt(Timestamp a, Timestamp b) public pure returns (bool isAfter) {
         return gtTimestamp(a, b);
@@ -99,22 +117,22 @@ library TimestampLib {
         return neTimestamp(a, b);
     }
 
-    /// @dev return true if Timestamp is larger than 0
-    function gtz(Timestamp timestamp) public pure returns (bool) {
-        return Timestamp.unwrap(timestamp) > 0;
-    }
-
     /// @dev return true if Timestamp equals 0
     function eqz(Timestamp timestamp) public pure returns (bool) {
         return Timestamp.unwrap(timestamp) == 0;
     }
 
+    /// @dev return true if Timestamp is larger than 0
+    function gtz(Timestamp timestamp) public pure returns (bool) {
+        return Timestamp.unwrap(timestamp) > 0;
+    }
+
     /// @dev return true if Timestamp a is not equal to Timestamp b
     function addSeconds(
         Timestamp timestamp,
-        uint256 timeDelta
+        Seconds duration
     ) public pure returns (Timestamp) {
-        return toTimestamp(Timestamp.unwrap(timestamp) + uint40(timeDelta));
+        return toTimestamp(Timestamp.unwrap(timestamp) + duration.toInt());
     }
 
     function toInt(Timestamp timestamp) public pure returns (uint256) {

package/contracts/{types → type}/UFixed.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 
-/// @dev UFixed is a fixed point number with 18 decimals precision.
-type UFixed is uint256;
+/// @dev UFixed is a 129-bit fixed point number with 12 decimals precision.
+type UFixed is uint128; 
 
 using {
     addUFixed as +,
@@ -16,28 +16,41 @@ using {
     ltUFixed as <,
     lteUFixed as <=,
     eqUFixed as ==,
-    UFixedMathLib.toInt
+    neUFixed as !=,
+    UFixedLib.gt,
+    UFixedLib.gtz,
+    UFixedLib.toInt,
+    UFixedLib.toInt1000
 } for UFixed global;
 
+// TODO move to UFixedLib and rename to zero()
+function zeroUFixed() pure returns (UFixed zero) {
+    return UFixed.wrap(0);
+}
+
 function addUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return UFixed.wrap(UFixed.unwrap(a) + UFixed.unwrap(b));
 }
 
 function subUFixed(UFixed a, UFixed b) pure returns (UFixed) {
-    require(a >= b, "ERROR:UFM-010:NEGATIVE_RESULT");
+    if (a < b) {
+        revert UFixedLib.UFixedLibNegativeResult();
+    }
     return UFixed.wrap(UFixed.unwrap(a) - UFixed.unwrap(b));
 }
 
 function mulUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return
-        UFixed.wrap(Math.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 18));
+        UFixed.wrap(uint128(Math.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 12)));
 }
 
 function divUFixed(UFixed a, UFixed b) pure returns (UFixed) {
-    require(UFixed.unwrap(b) > 0, "ERROR:UFM-020:DIVISOR_ZERO");
-
+    if (UFixed.unwrap(b) == 0) {
+        revert UFixedLib.UFixedLibDivisionByZero();
+    }
+    
     return
-        UFixed.wrap(Math.mulDiv(UFixed.unwrap(a), 10 ** 18, UFixed.unwrap(b)));
+        UFixed.wrap(uint128(Math.mulDiv(UFixed.unwrap(a), 10 ** 12, UFixed.unwrap(b))));
 }
 
 function gtUFixed(UFixed a, UFixed b) pure returns (bool isGreaterThan) {
@@ -60,6 +73,10 @@ function eqUFixed(UFixed a, UFixed b) pure returns (bool isEqual) {
     return UFixed.unwrap(a) == UFixed.unwrap(b);
 }
 
+function neUFixed(UFixed a, UFixed b) pure returns (bool isEqual) {
+    return UFixed.unwrap(a) != UFixed.unwrap(b);
+}
+
 function gtzUFixed(UFixed a) pure returns (bool isZero) {
     return UFixed.unwrap(a) > 0;
 }
@@ -76,8 +93,14 @@ function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return b - a;
 }
 
-library UFixedMathLib {
-    int8 public constant EXP = 18;
+library UFixedLib {
+    error UFixedLibNegativeResult();
+    error UFixedLibDivisionByZero();
+
+    error UFixedLibExponentTooSmall(int8 exp);
+    error UFixedLibExponentTooLarge(int8 exp);
+
+    int8 public constant EXP = 12;
     uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
     uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
 
@@ -98,15 +121,19 @@ library UFixedMathLib {
 
     /// @dev Converts the uint256 to a UFixed.
     function toUFixed(uint256 a) public pure returns (UFixed) {
-        return UFixed.wrap(a * MULTIPLIER);
+        return UFixed.wrap(uint128(a * MULTIPLIER));
     }
 
     /// @dev Converts the uint256 to a UFixed with given exponent.
     function toUFixed(uint256 a, int8 exp) public pure returns (UFixed) {
-        require(EXP + exp >= 0, "ERROR:FM-010:EXPONENT_TOO_SMALL");
-        require(EXP + exp <= 64, "ERROR:FM-011:EXPONENT_TOO_LARGE");
-
-        return UFixed.wrap(a * 10 ** uint8(EXP + exp));
+        if (EXP + exp < 0) {
+            revert UFixedLibExponentTooSmall(exp);
+        }
+        if (EXP + exp > 32) {
+            revert UFixedLibExponentTooLarge(exp);
+        }
+        
+        return UFixed.wrap(uint128(a * 10 ** uint8(EXP + exp)));
     }
 
     /// @dev returns the decimals precision of the UFixed type
@@ -119,6 +146,11 @@ library UFixedMathLib {
         return toIntWithRounding(a, ROUNDING_HALF_UP());
     }
 
+    /// @dev Converts a UFixed to a uint256.
+    function toInt1000(UFixed a) public pure returns (uint256) {
+        return toIntWithRounding(toUFixed(1000) * a, ROUNDING_HALF_UP());
+    }
+
     /// @dev Converts a UFixed to a uint256 with given rounding mode.
     function toIntWithRounding(UFixed a, uint8 rounding) public pure returns (uint256) {
         if (rounding == ROUNDING_HALF_UP()) {
@@ -127,7 +159,7 @@ library UFixedMathLib {
                     UFixed.unwrap(a) + MULTIPLIER_HALF,
                     1,
                     MULTIPLIER,
-                    Math.Rounding.Down
+                    Math.Rounding.Floor
                 );
         } else if (rounding == ROUNDING_DOWN()) {
             return
@@ -135,11 +167,11 @@ library UFixedMathLib {
                     UFixed.unwrap(a),
                     1,
                     MULTIPLIER,
-                    Math.Rounding.Down
+                    Math.Rounding.Floor
                 );
         } else {
             return
-                Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Up);
+                Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Ceil);
         }
     }
 
@@ -202,6 +234,10 @@ library UFixedMathLib {
         return UFixed.wrap(0);
     }
 
+    function one() public pure returns (UFixed) {
+        return UFixed.wrap(uint128(MULTIPLIER));
+    }
+
     /// @dev return the absolute delta between two UFixed numbers
     function delta(UFixed a, UFixed b) public pure returns (UFixed) {
         return deltaUFixed(a, b);

package/contracts/type/Version.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+type VersionPart is uint8;
+
+using {
+    versionPartGt as >,
+    versionPartEq as ==,
+    versionPartNe as !=,
+    VersionPartLib.eqz,
+    VersionPartLib.gtz,
+    VersionPartLib.toInt,
+    VersionPartLib.toString,
+    VersionPartLib.isValidRelease
+}
+    for VersionPart global;
+
+function versionPartGt(VersionPart a, VersionPart b) pure returns(bool isGreaterThan) { return VersionPart.unwrap(a) > VersionPart.unwrap(b); }
+function versionPartEq(VersionPart a, VersionPart b) pure returns(bool isSame) { return VersionPart.unwrap(a) == VersionPart.unwrap(b); }
+function versionPartNe(VersionPart a, VersionPart b) pure returns(bool isSame) { return VersionPart.unwrap(a) != VersionPart.unwrap(b); }
+
+library VersionPartLib {
+
+    error ErrorReleaseTooBig(VersionPart releaseMax, VersionPart release);
+
+    function releaseMin() public pure returns (VersionPart) { return toVersionPart(3); }
+    function releaseMax() public pure returns (VersionPart) { return toVersionPart(99); }
+
+    function isValidRelease(VersionPart release) external pure returns(bool) { 
+        uint256 releaseInt = VersionPart.unwrap(release);
+        return 3 <= releaseInt && releaseInt <= 99; 
+    } 
+
+    function toString(VersionPart a) external pure returns (string memory) {
+        if (a > releaseMax()) {
+            revert ErrorReleaseTooBig(releaseMax(), a);
+        }
+
+        uint256 value = VersionPart.unwrap(a);
+        if (value == 0) {
+            return "0";
+        }
+
+        uint256 temp = value;
+        uint256 digits = 0;
+        while (temp != 0) {
+            digits++;
+            temp /= 10;
+        }
+
+        bytes memory buffer = new bytes(digits);
+        uint index = digits - 1;
+
+        temp = value;
+        while (temp != 0) {
+            buffer[index] = bytes1(uint8(48 + temp % 10));
+            temp /= 10;
+
+            if (index > 0) {
+                index--;
+            }
+        }
+
+        return string(buffer);
+    }
+
+    function eqz(VersionPart a) external pure returns(bool) { return VersionPart.unwrap(a) == 0; }
+    function gtz(VersionPart a) external pure returns(bool) { return VersionPart.unwrap(a) > 0; }
+    function toInt(VersionPart a) external pure returns(uint256) { return VersionPart.unwrap(a); }
+    function toVersionPart(uint256 a) public pure returns(VersionPart) { return VersionPart.wrap(uint8(a)); }
+}
+
+type Version is uint24; // contains major,minor,patch version parts
+
+using {
+    versionGt as >,
+    versionEq as ==,
+    VersionLib.toInt,
+    VersionLib.toUint64,
+    VersionLib.toMajorPart,
+    VersionLib.toVersionParts
+}
+    for Version global;
+
+function versionGt(Version a, Version b) pure returns(bool isGreaterThan) { return Version.unwrap(a) > Version.unwrap(b); }
+function versionEq(Version a, Version b) pure returns(bool isSame) { return Version.unwrap(a) == Version.unwrap(b); }
+
+library VersionLib {
+
+    function toInt(Version version) external pure returns(uint) { return Version.unwrap(version); }
+
+    function toUint64(Version version) external pure returns(uint64) { return Version.unwrap(version); }
+
+    function toMajorPart(Version version)
+        external    
+        pure 
+        returns(VersionPart major)
+    { 
+        uint24 versionInt = Version.unwrap(version);
+        uint8 majorInt = uint8(versionInt >> 16);
+        return VersionPart.wrap(majorInt);
+    }
+
+    function toVersionParts(Version version)
+        external
+        pure
+        returns(
+            VersionPart major,
+            VersionPart minor,
+            VersionPart patch
+        )
+    {
+        uint24 versionInt = Version.unwrap(version);
+        uint8 majorInt = uint8(versionInt >> 16);
+
+        versionInt -= majorInt << 16;
+        uint8 minorInt = uint8(versionInt >> 8);
+        uint8 patchInt = uint8(versionInt - (minorInt << 8));
+
+        return (
+            VersionPart.wrap(majorInt),
+            VersionPart.wrap(minorInt),
+            VersionPart.wrap(patchInt)
+        );
+    }
+
+    // function toVersionPart(uint256 versionPart) public pure returns(VersionPart) { 
+    //     return VersionPart.wrap(uint8(versionPart)); 
+    // }
+
+    function toVersion(
+        uint256 major,
+        uint256 minor,
+        uint256 patch
+    )
+        external
+        pure
+        returns(Version)
+    {
+        require(
+            major < 256 && minor < 256 && patch < 256,
+            "ERROR:VRS-010:VERSION_PART_TOO_BIG");
+
+        return Version.wrap(
+            uint24(
+                (major << 16) + (minor << 8) + patch));
+    }
+
+    // TODO check for overflow?
+    function toVersion(uint64 versionNumber) external pure returns(Version) {
+        //assert(versionNumber <= type(Version).max);
+        return Version.wrap(uint24(versionNumber));
+    }
+
+    // TODO rename to zero()
+    function zeroVersion() external pure returns(Version) {
+        return Version.wrap(0);
+    }
+}

package/contracts/upgradeability/IVersionable.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Version} from "../type/Version.sol";
+
+/// IMPORTANT
+// Upgradeable contract MUST:
+// 1) inherit from Versionable
+// 2) implement version() function
+// 3) implement internal _initialize() function with onlyInitializing modifier 
+// 4) implement internal _upgrade() function with onlyInitializing modifier (1st version MUST revert)
+// 5) have onlyInitialising modifier for each function callable inside _initialize()/_upgrade() (MUST use different functions for initialization/upgrade and normal operations)
+// 6) use default empty constructor -> _disableInitializer() is called from Versionable contructor
+// 7) use namespace storage (should this be needed)
+// 8) since now inheritance is used for upgradability, contract MUST BE inherited ONLY by the next version 
+// Upgradeable contract SHOULD:
+// 9) define all non private methods as virtual (in order to be able to upgrade them latter)
+//    otherwise, it is still possible to upgrade contract, but everyone who is using it will have to switch to a new fucntions
+//    in some cases this ok but not in the others...
+//
+// IMPORTANT
+// If introducting/amending storage related to Versionable version MUST:
+// 1) define namespace storage struct if accessing storage
+//      - DO NOT use structs inside, except
+//      - CAN use structs ONLY inside mappings
+// 2) ALWAYS define private getter if accessing storage
+//      - MUST use default implementation, CAN change ONLY return type
+
+interface IVersionable {
+
+    /**
+     * @dev IMPORTANT
+     * implementation MUST be guarded by initializer modifier
+     * new version MUST inherit from previous version
+     */
+    function initializeVersionable(address activatedBy, bytes memory activationData) external;
+
+    /**
+     * @dev
+     * implementation MUST be guarded by reinitializer(version().toUint64()) modifier
+     * new version MUST inherit from previous version
+     * the first verion MUST revert 
+     */
+    function upgradeVersionable(bytes memory upgradeData) external;
+
+    /**
+     * @dev returns version of this contract
+     * each new implementation MUST implement this function
+     * version number MUST increase 
+     */
+    function getVersion() external pure returns(Version);
+
+}