@etherisc/gif-next 0.0.2-d288ca9-933 → 0.0.2-d2f2474-604

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

@@ -9,11 +9,37 @@ using {
     eqStateId as ==, 
     neStateId as !=, 
     StateIdLib.eqz,
+    StateIdLib.eq,
     StateIdLib.gtz,
     StateIdLib.toInt
 } for StateId global;
 
 // general pure free functions
+
+function INITIAL() pure returns (StateId) {
+    return toStateId(1);
+}
+
+function SCHEDULED() pure returns (StateId) {
+    return toStateId(2);
+}
+
+function DEPLOYING() pure returns (StateId) {
+    return toStateId(3);
+}
+
+function DEPLOYED() pure returns (StateId) {
+    return toStateId(4);
+}
+
+function ACTIVE() pure returns (StateId) {
+    return toStateId(5);
+}
+
+function SKIPPED() pure returns (StateId) {
+    return toStateId(6);
+}
+
 function APPLIED() pure returns (StateId) {
     return toStateId(10);
 }
@@ -26,20 +52,32 @@ function DECLINED() pure returns (StateId) {
     return toStateId(30);
 }
 
-function UNDERWRITTEN() pure returns (StateId) {
+function COLLATERALIZED() pure returns (StateId) {
     return toStateId(40);
 }
 
-function CONFIRMED() pure returns (StateId) {
+function SUBMITTED() pure returns (StateId) {
     return toStateId(50);
 }
 
+function CONFIRMED() pure returns (StateId) {
+    return toStateId(51);
+}
+
 function EXPECTED() pure returns (StateId) {
     return toStateId(60);
 }
 
-function ACTIVE() pure returns (StateId) {
-    return toStateId(100);
+function FULFILLED() pure returns (StateId) {
+    return toStateId(70);
+}
+
+function FAILED() pure returns (StateId) {
+    return toStateId(7);
+}
+
+function CANCELLED() pure returns (StateId) {
+    return toStateId(72);
 }
 
 function PAUSED() pure returns (StateId) {
@@ -58,11 +96,16 @@ function PAID() pure returns (StateId) {
     return toStateId(220);
 }
 
+function KEEP_STATE() pure returns (StateId) {
+    return toStateId(type(uint8).max);
+}
+
 /// @dev Converts the uint8 to a StateId.
 function toStateId(uint256 id) pure returns (StateId) {
     return StateId.wrap(uint8(id));
 }
 
+// TODO move to StateIdLib and rename to zero()
 /// @dev Return the StateId zero (0)
 function zeroStateId() pure returns (StateId) {
     return StateId.wrap(0);
@@ -79,6 +122,11 @@ function neStateId(StateId a, StateId b) pure returns (bool isDifferent) {
 
 // library functions that operate on user defined type
 library StateIdLib {
+
+    function zero() public pure returns (StateId) {
+        return StateId.wrap(0);
+    }
+
     /// @dev Converts the NftId to a uint256.
     function toInt(StateId stateId) public pure returns (uint96) {
         return uint96(StateId.unwrap(stateId));

package/contracts/type/String.sol

@@ -0,0 +1,65 @@
+// 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;
+
+// pure free function needed for the operator overloading
+function StrEq(Str s1, Str s2) pure returns (bool) {
+    return StrLib.eq(s1, s2);
+}
+
+// pure free function needed for the operator overloading
+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 return true iff s1 equals from s2
+    function eq(string memory s1, string memory s2) public pure returns (bool) {
+        return keccak256(bytes(s1)) == keccak256(bytes(s2));
+    }
+
+    /// @dev return true iff s1 differs s2
+    function ne(string memory s1, string memory s2) public pure returns (bool) {
+        return !eq(s1, 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,6 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
+import {Seconds} from "./Seconds.sol";
+
+/// @dev Target: Cover 10 years with 1 ms block time resolution.
+/// Typical block time resolution is 1s.
 type Timestamp is uint40;
 
 using {
@@ -10,9 +14,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,24 +56,29 @@ 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 blockTimestamp() public view returns (Timestamp) {
+
+    function zero() public pure returns (Timestamp) {
+        return Timestamp.wrap(0);
+    }
+
+    function max() public pure returns (Timestamp) {
+        return Timestamp.wrap(type(uint40).max);
+    }
+
+    function current() 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) {
@@ -103,22 +119,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/type/UFixed.sol

@@ -0,0 +1,263 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+
+/// @dev UFixed is a 160-bit fixed point number with 15 decimals precision.
+type UFixed is uint160; 
+
+using {
+    addUFixed as +,
+    subUFixed as -,
+    mulUFixed as *,
+    divUFixed as /,
+    gtUFixed as >,
+    gteUFixed as >=,
+    ltUFixed as <,
+    lteUFixed as <=,
+    eqUFixed as ==,
+    neUFixed as !=,
+    UFixedLib.gt,
+    UFixedLib.eqz,
+    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) {
+    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(uint160(Math.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 15)));
+}
+
+function divUFixed(UFixed a, UFixed b) pure returns (UFixed) {
+    if (UFixed.unwrap(b) == 0) {
+        revert UFixedLib.UFixedLibDivisionByZero();
+    }
+    
+    return
+        UFixed.wrap(uint160(Math.mulDiv(UFixed.unwrap(a), 10 ** 15, UFixed.unwrap(b))));
+}
+
+function gtUFixed(UFixed a, UFixed b) pure returns (bool isGreaterThan) {
+    return UFixed.unwrap(a) > UFixed.unwrap(b);
+}
+
+function gteUFixed(UFixed a, UFixed b) pure returns (bool isGreaterThan) {
+    return UFixed.unwrap(a) >= UFixed.unwrap(b);
+}
+
+function ltUFixed(UFixed a, UFixed b) pure returns (bool isGreaterThan) {
+    return UFixed.unwrap(a) < UFixed.unwrap(b);
+}
+
+function lteUFixed(UFixed a, UFixed b) pure returns (bool isGreaterThan) {
+    return UFixed.unwrap(a) <= UFixed.unwrap(b);
+}
+
+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;
+}
+
+function eqzUFixed(UFixed a) pure returns (bool isZero) {
+    return UFixed.unwrap(a) == 0;
+}
+
+function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
+    if (a > b) {
+        return a - b;
+    }
+
+    return b - a;
+}
+
+library UFixedLib {
+    error UFixedLibNegativeResult();
+    error UFixedLibDivisionByZero();
+
+    error UFixedLibExponentTooSmall(int8 exp);
+    error UFixedLibExponentTooLarge(int8 exp);
+
+    error UFixedLibNumberTooLarge(uint256 number);
+
+    int8 public constant EXP = 15;
+    uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
+    uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
+
+    /// @dev returns the rounding mode DOWN - 0.4 becomes 0, 0.5 becomes 0, 0.6 becomes 0
+    function ROUNDING_DOWN() public pure returns (uint8) {
+        return uint8(0);
+    }
+
+    /// @dev returns the rounding mode UP - 0.4 becomes 1, 0.5 becomes 1, 0.6 becomes 1
+    function ROUNDING_UP() public pure returns (uint8) {
+        return uint8(1);
+    }
+
+    /// @dev returns the rounding mode HALF_UP - 0.4 becomes 0, 0.5 becomes 1, 0.6 becomes 1
+    function ROUNDING_HALF_UP() public pure returns (uint8) {
+        return uint8(2);
+    }
+
+    /// @dev Converts the uint256 to a uint160 based UFixed. 
+    /// This method reverts if the number is too large to fit in a uint160.
+    function toUFixed(uint256 a) public pure returns (UFixed) {
+        uint256 n = a * MULTIPLIER;
+        if (n > type(uint160).max) {
+            revert UFixedLibNumberTooLarge(a);
+        }
+        return UFixed.wrap(uint160(n));
+    }
+
+    /// @dev Converts the uint256 to a UFixed with given exponent.
+    function toUFixed(uint256 a, int8 exp) public pure returns (UFixed) {
+        if (EXP + exp < 0) {
+            revert UFixedLibExponentTooSmall(exp);
+        }
+        if (EXP + exp > 48) {
+            revert UFixedLibExponentTooLarge(exp);
+        }
+        
+        uint256 n = a * 10 ** uint8(EXP + exp);
+
+        if (n > type(uint160).max) {
+            revert UFixedLibNumberTooLarge(n);
+        }
+
+        return UFixed.wrap(uint160(n));
+    }
+
+    /// @dev returns the decimals precision of the UFixed type
+    function decimals() public pure returns (uint256) {
+        return uint8(EXP);
+    }
+
+    /// @dev Converts a UFixed to a uint256.
+    function toInt(UFixed a) public pure returns (uint256) {
+        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()) {
+            return
+                Math.mulDiv(
+                    UFixed.unwrap(a) + MULTIPLIER_HALF,
+                    1,
+                    MULTIPLIER,
+                    Math.Rounding.Floor
+                );
+        } else if (rounding == ROUNDING_DOWN()) {
+            return
+                Math.mulDiv(
+                    UFixed.unwrap(a),
+                    1,
+                    MULTIPLIER,
+                    Math.Rounding.Floor
+                );
+        } else {
+            return
+                Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Ceil);
+        }
+    }
+
+    /// @dev adds two UFixed numbers
+    function add(UFixed a, UFixed b) public pure returns (UFixed) {
+        return addUFixed(a, b);
+    }
+
+    /// @dev subtracts two UFixed numbers
+    function sub(UFixed a, UFixed b) public pure returns (UFixed) {
+        return subUFixed(a, b);
+    }
+
+    /// @dev multiplies two UFixed numbers
+    function mul(UFixed a, UFixed b) public pure returns (UFixed) {
+        return mulUFixed(a, b);
+    }
+
+    /// @dev divides two UFixed numbers
+    function div(UFixed a, UFixed b) public pure returns (UFixed) {
+        return divUFixed(a, b);
+    }
+
+    /// @dev return true if UFixed a is greater than UFixed b
+    function gt(UFixed a, UFixed b) public pure returns (bool isGreaterThan) {
+        return gtUFixed(a, b);
+    }
+
+    /// @dev return true if UFixed a is greater than or equal to UFixed b
+    function gte(UFixed a, UFixed b) public pure returns (bool isGreaterThan) {
+        return gteUFixed(a, b);
+    }
+
+    /// @dev return true if UFixed a is less than UFixed b
+    function lt(UFixed a, UFixed b) public pure returns (bool isGreaterThan) {
+        return ltUFixed(a, b);
+    }
+
+    /// @dev return true if UFixed a is less than or equal to UFixed b
+    function lte(UFixed a, UFixed b) public pure returns (bool isGreaterThan) {
+        return lteUFixed(a, b);
+    }
+
+    /// @dev return true if UFixed a is equal to UFixed b
+    function eq(UFixed a, UFixed b) public pure returns (bool isEqual) {
+        return eqUFixed(a, b);
+    }
+
+    /// @dev return true if UFixed a is not zero
+    function gtz(UFixed a) public pure returns (bool isZero) {
+        return gtzUFixed(a);
+    }
+
+    /// @dev return true if UFixed a is zero
+    function eqz(UFixed a) public pure returns (bool isZero) {
+        return eqzUFixed(a);
+    }
+
+    function zero() public pure returns (UFixed) {
+        return UFixed.wrap(0);
+    }
+
+    function one() public pure returns (UFixed) {
+        return UFixed.wrap(uint160(MULTIPLIER));
+    }
+
+    function max() public pure returns (UFixed) {
+        return UFixed.wrap(type(uint160).max);
+    }
+
+    /// @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);
     }