@etherisc/gif-next 0.0.2-743affe-003 → 0.0.2-754ba48-078

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,5 +1,5 @@
 // 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";
 
@@ -16,15 +16,26 @@ 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));
 }
 
@@ -34,8 +45,10 @@ function mulUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 }
 
 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)));
 }
@@ -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,7 +93,13 @@ function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return b - a;
 }
 
-library UFixedMathLib {
+library UFixedLib {
+    error UFixedLibNegativeResult();
+    error UFixedLibDivisionByZero();
+
+    error UFixedLibExponentTooSmall(int8 exp);
+    error UFixedLibExponentTooLarge(int8 exp);
+
     int8 public constant EXP = 18;
     uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
     uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
@@ -103,9 +126,13 @@ library UFixedMathLib {
 
     /// @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");
-
+        if (EXP + exp < 0) {
+            revert UFixedLibExponentTooSmall(exp);
+        }
+        if (EXP + exp > 64) {
+            revert UFixedLibExponentTooLarge(exp);
+        }
+        
         return UFixed.wrap(a * 10 ** uint8(EXP + exp));
     }
 
@@ -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(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/{types → type}/Version.sol

@@ -1,20 +1,73 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 type VersionPart is uint8;
 
 using {
     versionPartGt as >,
     versionPartEq as ==,
-    VersionPartLib.toInt
+    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 {
-    function toInt(VersionPart x) external pure returns(uint) { return VersionPart.unwrap(x); }
+
+    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
@@ -33,6 +86,7 @@ function versionGt(Version a, Version b) pure returns(bool isGreaterThan) { retu
 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); }
@@ -70,9 +124,9 @@ library VersionLib {
         );
     }
 
-    function toVersionPart(uint256 versionPart) external pure returns(VersionPart) { 
-        return VersionPart.wrap(uint8(versionPart)); 
-    }
+    // function toVersionPart(uint256 versionPart) public pure returns(VersionPart) { 
+    //     return VersionPart.wrap(uint8(versionPart)); 
+    // }
 
     function toVersion(
         uint256 major,
@@ -98,6 +152,7 @@ library VersionLib {
         return Version.wrap(uint24(versionNumber));
     }
 
+    // TODO rename to zero()
     function zeroVersion() external pure returns(Version) {
         return Version.wrap(0);
     }

package/contracts/{shared → upgradeability}/IVersionable.sol

@@ -1,10 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Blocknumber} from "../types/Blocknumber.sol";
-import {Timestamp} from "../types/Timestamp.sol";
-import {Version} from "../types/Version.sol";
-
+import {Version} from "../type/Version.sol";
 
 /// IMPORTANT
 // Upgradeable contract MUST:
@@ -14,7 +11,7 @@ import {Version} from "../types/Version.sol";
 // 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
+// 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)
@@ -22,48 +19,29 @@ import {Version} from "../types/Version.sol";
 //    in some cases this ok but not in the others...
 //
 // IMPORTANT
-// Each version MUST:
+// 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
-//      - MUST use the same "LOCATION_V1"
 
 interface IVersionable {
 
-    struct VersionInfo {
-        Version version;
-        address implementation;
-        address activatedBy;
-        Timestamp activatedAt;
-        Blocknumber activatedIn;
-    }
-
-    event LogVersionableInitialized(Version version, address implementation, address activatedBy);
-
-    // TODO uncomment when all implementations are ready
     /**
      * @dev IMPORTANT
      * implementation MUST be guarded by initializer modifier
-     * implementation MUST call internal function Versionable._updateVersionHistory 
      * new version MUST inherit from previous version
      */
-    function initialize(address implementation, address activatedBy, bytes memory activationData) external;
+    function initializeVersionable(address activatedBy, bytes memory activationData) external;
 
     /**
      * @dev
      * implementation MUST be guarded by reinitializer(version().toUint64()) modifier
-     * implementation MUST call internal function Versionable._updateVersionHistory
      * new version MUST inherit from previous version
      * the first verion MUST revert 
      */
-    function upgrade(address implementation, address activatedBy, bytes memory upgradeData) external;
-
-    /**
-     * @dev returns true if the specified version has been activated for the current contract
-     */
-    function isInitialized(Version version) external view returns(bool);
+    function upgradeVersionable(bytes memory upgradeData) external;
 
     /**
      * @dev returns version of this contract
@@ -72,25 +50,4 @@ interface IVersionable {
      */
     function getVersion() external pure returns(Version);
 
-    /**
-     * @dev returns the number of all deployed versions of this contract
-     */
-    function getVersionCount() external view returns(uint256 numberOfVersions);
-
-    /**
-     * @dev returns the i-th (index) version of this contract
-     */
-    function getVersion(uint256 index) external view returns(Version version);
-
-    /**
-     * @dev returns the i-th (index) version info of this contract
-     */
-    function getVersionInfo(Version version) external view returns(VersionInfo memory versionInfo);
-
-    // TODO make sure it is needed here
-    /**
-     * @dev returns currently active version
-     */
-    function getInitializedVersion() external view returns(uint64);
-
 }