@etherisc/gif-next 0.0.2-da77c50-824 → 0.0.2-de220d6-949

package/contracts/instance/service/PoolService.sol

@@ -10,10 +10,10 @@ import {Versionable} from "../../shared/Versionable.sol";
 
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 import {POOL, BUNDLE} from "../../types/ObjectType.sol";
-import {Fee, feeIsZero} from "../../types/Fee.sol";
-import {Version, toVersion, toVersionPart} from "../../types/Version.sol";
+import {Fee} from "../../types/Fee.sol";
+import {Version, VersionLib} from "../../types/Version.sol";
 
-import {ComponentServiceBase} from "./ComponentServiceBase.sol";
+import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
 import {IPoolService} from "./IPoolService.sol";
 
 
@@ -36,10 +36,7 @@ contract PoolService is ComponentServiceBase, IPoolService {
         virtual override (IVersionable, Versionable)
         returns(Version)
     {
-        return toVersion(
-            toVersionPart(3),
-            toVersionPart(0),
-            toVersionPart(0));
+        return VersionLib.toVersion(3,0,0);
     }
 
     function getName() external pure override returns(string memory name) {
@@ -59,7 +56,7 @@ contract PoolService is ComponentServiceBase, IPoolService {
 
     function createBundle(
         address owner, 
-        uint256 amount, 
+        uint256 stakingAmount, 
         uint256 lifetime, 
         bytes calldata filter
     )
@@ -81,7 +78,7 @@ contract PoolService is ComponentServiceBase, IPoolService {
         instance.createBundleInfo(
             bundleNftId,
             poolNftId,
-            amount,
+            stakingAmount,
             lifetime,
             filter);
 
@@ -89,10 +86,38 @@ contract PoolService is ComponentServiceBase, IPoolService {
         instance.addBundleToPool(
             bundleNftId,
             poolNftId,
-            amount);
+            stakingAmount);
 
-        // TODO collect capital
+        // collect capital
+        _processStakingByTreasury(
+            instance,
+            poolNftId,
+            bundleNftId,
+            stakingAmount);
 
         // TODO add logging
     }
+
+
+    function _processStakingByTreasury(
+        IInstance instance,
+        NftId poolNftId,
+        NftId bundleNftId,
+        uint256 stakingAmount
+    )
+        internal
+    {
+        // process token transfer(s)
+        if(stakingAmount > 0) {
+            TokenHandler tokenHandler = instance.getTokenHandler(poolNftId);
+            address bundleOwner = _registry.getOwner(bundleNftId);
+            address poolWallet = instance.getPoolSetup(poolNftId).wallet;
+
+            tokenHandler.transfer(
+                bundleOwner,
+                poolWallet,
+                stakingAmount
+            );
+        }
+    }
 }

package/contracts/instance/service/ProductService.sol

@@ -19,10 +19,10 @@ import {ObjectType, INSTANCE, PRODUCT, POLICY} from "../../types/ObjectType.sol"
 import {APPLIED, UNDERWRITTEN, ACTIVE} from "../../types/StateId.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 import {Blocknumber, blockNumber} from "../../types/Blocknumber.sol";
-import {Fee, feeIsZero} from "../../types/Fee.sol";
-import {Version, toVersion, toVersionPart} from "../../types/Version.sol";
+import {Fee, FeeLib} from "../../types/Fee.sol";
+import {Version, VersionLib} from "../../types/Version.sol";
 
-import {ComponentServiceBase} from "./ComponentServiceBase.sol";
+import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
 import {IProductService} from "./IProductService.sol";
 
 // TODO or name this ProtectionService to have Product be something more generic (loan, savings account, ...)
@@ -47,10 +47,7 @@ contract ProductService is ComponentServiceBase, IProductService {
         virtual override (IVersionable, Versionable)
         returns(Version)
     {
-        return toVersion(
-            toVersionPart(3),
-            toVersionPart(0),
-            toVersionPart(0));
+        return VersionLib.toVersion(3,0,0);
     }
 
     function getName() external pure override returns(string memory name) {
@@ -137,7 +134,6 @@ contract ProductService is ComponentServiceBase, IProductService {
         returns (IBundle.BundleInfo memory)
     {
         bundleInfo.lockedAmount += collateralAmount;
-        bundleInfo.updatedIn = blockNumber();
         instance.collateralizePolicy(bundleInfo.nftId, policyNftId, collateralAmount);
         return bundleInfo;
     }
@@ -154,7 +150,7 @@ contract ProductService is ComponentServiceBase, IProductService {
         IPoolComponent pool = IPoolComponent(poolAddress);
         pool.underwrite(
             policyInfo.nftId, 
-            policyInfo.data, 
+            policyInfo.applicationData, 
             bundleFilter,
             collateralAmount);
     }
@@ -329,13 +325,13 @@ contract ProductService is ComponentServiceBase, IProductService {
     {
         // process token transfer(s)
         if(premiumAmount > 0) {
-            TokenHandler tokenHandler = product.tokenHandler;
+            TokenHandler tokenHandler = instance.getTokenHandler(product.productNftId);
             address policyOwner = _registry.getOwner(policyNftId);
             address poolWallet = instance.getPoolSetup(product.poolNftId).wallet;
             netPremiumAmount = premiumAmount;
             Fee memory policyFee = product.policyFee;
 
-            if (feeIsZero(policyFee)) {
+            if (FeeLib.feeIsZero(policyFee)) {
                 tokenHandler.transfer(
                     policyOwner,
                     poolWallet,

package/contracts/registry/Registry.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.19;
 
 import {IRegisterable} from "../shared/IRegisterable.sol";
-import {IService} from "../instance/service/IService.sol";
+import {IService} from "../instance/base/IService.sol";
 
 import {IChainNft} from "./IChainNft.sol";
 import {ChainNft} from "./ChainNft.sol";

package/contracts/shared/IVersionable.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.19;
 
 import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
 import {Timestamp, blockTimestamp} from "../types/Timestamp.sol";
-import {Version, VersionPart, zeroVersion} from "../types/Version.sol";
+import {Version, VersionPart} from "../types/Version.sol";
 
 interface IVersionable {
 
@@ -11,8 +11,8 @@ interface IVersionable {
         Version version;
         address implementation;
         address activatedBy;
-        Blocknumber activatedIn;
         Timestamp activatedAt;
+        Blocknumber activatedIn;
     }
 
     event LogVersionableActivated(Version version, address implementation, address activatedBy);

package/contracts/shared/Versionable.sol

@@ -3,13 +3,12 @@ pragma solidity ^0.8.19;
 
 import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
 import {Timestamp, blockTimestamp} from "../types/Timestamp.sol";
-import {Version, VersionPart, zeroVersion} from "../types/Version.sol";
+import {Version, VersionPart} from "../types/Version.sol";
 
 import {IVersionable} from "./IVersionable.sol";
 
 abstract contract Versionable is IVersionable {
 
-
     mapping(Version version => VersionInfo info) private _versionHistory;
     Version [] private _versions;
 
@@ -58,8 +57,8 @@ abstract contract Versionable is IVersionable {
             thisVersion,
             implementation,
             activatedBy,
-            blockNumber(),
-            blockTimestamp()
+            blockTimestamp(),
+            blockNumber()
         );
 
         emit LogVersionableActivated(thisVersion, implementation, activatedBy);
@@ -80,13 +79,11 @@ abstract contract Versionable is IVersionable {
 
 
     function getVersion(uint256 idx) external view override returns(Version) {
-        require(idx < _versions.length, "ERROR:VRN-010:INDEX_TOO_LARGE");
         return _versions[idx];
     }
 
 
     function getVersionInfo(Version _version) external override view returns(VersionInfo memory) {
-        require(isActivated(_version), "ERROR:VRN-020:VERSION_UNKNOWN");
         return _versionHistory[_version];
     }
 }

package/contracts/test/TestFee.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.19;
 
 import {UFixed, UFixedMathLib} from "../types/UFixed.sol";
-import {Fee, toFee, zeroFee} from "../types/Fee.sol";
+import {Fee, FeeLib} from "../types/Fee.sol";
 
 contract TestFee {
 
@@ -15,11 +15,11 @@ contract TestFee {
         pure 
         returns(Fee memory fee)
     {
-        return toFee(UFixedMathLib.toUFixed(fractionalValue, exponent), fixedValue);
+        return FeeLib.toFee(UFixedMathLib.toUFixed(fractionalValue, exponent), fixedValue);
     }
 
     function getZeroFee() external pure returns(Fee memory fee) {
-        return zeroFee();
+        return FeeLib.zeroFee();
     }
 
 }

package/contracts/test/TestPool.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.19;
 
 import {NftId} from "../../contracts/types/NftId.sol";
 import {UFixed} from "../../contracts/types/UFixed.sol";
-import {Fee, zeroFee} from "../../contracts/types/Fee.sol";
+import {Fee} from "../../contracts/types/Fee.sol";
 import {Pool} from "../../contracts/components/Pool.sol";
 
 

package/contracts/test/TestProduct.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.19;
 import {Product} from "../../contracts/components/Product.sol";
 import {NftId, toNftId} from "../../contracts/types/NftId.sol";
 import {Timestamp, blockTimestamp} from "../../contracts/types/Timestamp.sol";
-import {Fee, zeroFee} from "../../contracts/types/Fee.sol";
+import {Fee} from "../../contracts/types/Fee.sol";
 
 contract TestProduct is Product {
 

package/contracts/test/TestRoleId.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {RoleId, toRoleId, PRODUCT_OWNER_ROLE_NAME, PRODUCT_OWNER_ROLE, POOL_OWNER_ROLE_NAME, POOL_OWNER_ROLE} from "../../contracts/types/RoleId.sol";
+import {RoleId, RoleIdLib, PRODUCT_OWNER_ROLE_NAME, PRODUCT_OWNER_ROLE, POOL_OWNER_ROLE_NAME, POOL_OWNER_ROLE} from "../../contracts/types/RoleId.sol";
 
 contract TestRoleId {
-    function getRole(string memory roleName) external pure returns (RoleId) { return toRoleId(roleName); }
+    function getRole(string memory roleName) external pure returns (RoleId) { return RoleIdLib.toRoleId(roleName); }
 
     function getProductOwnerRoleName() external pure returns (string memory) { return PRODUCT_OWNER_ROLE_NAME(); }
     function getProductOwnerRole() external pure returns (RoleId) { return PRODUCT_OWNER_ROLE(); } 

package/contracts/test/TestService.sol

@@ -2,8 +2,8 @@
 pragma solidity ^0.8.19;
 
 import {NftId} from "../../contracts/types/NftId.sol";
-import {Version, toVersion, toVersionPart} from "../../contracts/types/Version.sol";
-import {ServiceBase} from "../../contracts/instance/service/ServiceBase.sol";
+import {Version, VersionLib} from "../../contracts/types/Version.sol";
+import {ServiceBase} from "../../contracts/instance/base/ServiceBase.sol";
 
 import {IVersionable} from "../../contracts/shared/IVersionable.sol";
 import {Versionable} from "../../contracts/shared/Versionable.sol";
@@ -23,10 +23,7 @@ contract TestService is ServiceBase {
         virtual override (IVersionable, Versionable)
         returns(Version)
     {
-        return toVersion(
-            toVersionPart(3),
-            toVersionPart(0),
-            toVersionPart(0));
+        return VersionLib.toVersion(3,0,0);
     }
 
     function getName() external pure override returns(string memory name) {

package/contracts/test/TestVersion.sol

@@ -1,19 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {Version, VersionPart, toVersion, toVersionPart, zeroVersion} from "../types/Version.sol";
+import {Version, VersionPart, VersionLib} from "../types/Version.sol";
 
 contract TestVersion {
 
     function createVersion(uint major, uint minor, uint patch) external pure returns(Version) {
-        return toVersion(
-            toVersionPart(uint8(major)),
-            toVersionPart(uint8(minor)),
-            toVersionPart(uint8(patch)));
+        return VersionLib.toVersion(major, minor, patch);
     }
 
     function createVersionPart(uint versionPart) external pure returns(VersionPart) {
-        return toVersionPart(uint8(versionPart));
+        return VersionLib.toVersionPart(uint8(versionPart));
     }
 
     function getVersionParts(Version version)
@@ -33,7 +30,7 @@ contract TestVersion {
     }
 
     function getZeroVersion() external pure returns(Version) {
-        return zeroVersion();
+        return VersionLib.zeroVersion();
     }
 
     function isSameVersion(Version a, Version b) external pure returns(bool) {

package/contracts/test/TestVersionable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {Version, toVersion, toVersionPart} from "../../contracts/types/Version.sol";
+import {Version, VersionLib} from "../../contracts/types/Version.sol";
 import {Versionable} from "../../contracts/shared/Versionable.sol";
 
 contract TestVersionable is Versionable {
@@ -12,9 +12,6 @@ contract TestVersionable is Versionable {
         virtual override
         returns(Version)
     {
-        return toVersion(
-            toVersionPart(3),
-            toVersionPart(0),
-            toVersionPart(0));
+        return VersionLib.toVersion(3,0,0);
     }
 }

package/contracts/test/Usdc.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract USDC is ERC20 {
+
+    // https://etherscan.io/token/0xc719d010b63e5bbf2c0551872cd5316ed26acd83#readContract
+    string public constant NAME = "USDC - DUMMY";
+    string public constant SYMBOL = "USDC";
+    uint8 public constant DECIMALS = 6;
+    uint256 public constant INITIAL_SUPPLY = 10**9 * 10**DECIMALS; // 1 Billion 1'000'000'000
+    // decimals == 18 (openzeppelin erc20 default)
+    constructor()
+        ERC20(NAME, SYMBOL)
+    {
+        _mint(
+            _msgSender(),
+            INITIAL_SUPPLY
+        );   
+    }
+
+    function decimals() public pure override returns(uint8) {
+        return DECIMALS;
+    }
+}

package/contracts/types/Fee.sol

@@ -1,32 +1,51 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {UFixed} from "./UFixed.sol";
+import {UFixed, UFixedMathLib} from "./UFixed.sol";
 
 struct Fee {
     UFixed fractionalFee;
     uint256 fixedFee;
 }
 
-// general pure free functions
-/// @dev Converts the uint256 to a NftId.
-function toFee(
-    UFixed fractionalFee,
-    uint256 fixedFee
-) pure returns (Fee memory fee) {
-    return Fee(fractionalFee, fixedFee);
-}
+library FeeLib {
 
-/// @dev Return the NftId zero (0)
-function zeroFee() pure returns (Fee memory fee) {
-    return Fee(UFixed.wrap(0), 0);
-}
+    function calculateFee(
+        uint256 amount,
+        Fee memory fee
+    )
+        public
+        pure
+        returns (
+            uint256 feeAmount, 
+            uint256 netAmount
+        )
+    {
+        UFixed fractionalAmount = UFixedMathLib.toUFixed(amount) *
+            fee.fractionalFee;
+        feeAmount = fractionalAmount.toInt() + fee.fixedFee;
+        netAmount = amount - feeAmount;
+    }
 
-// pure free functions for operators
-function feeIsSame(Fee memory a, Fee memory b) pure returns (bool isSame) {
-    return a.fixedFee == b.fixedFee && a.fractionalFee == b.fractionalFee;
-}
+    /// @dev Converts the uint256 to a fee struct.
+    function toFee(
+        UFixed fractionalFee,
+        uint256 fixedFee
+    ) public pure returns (Fee memory fee) {
+        return Fee(fractionalFee, fixedFee);
+    }
 
-function feeIsZero(Fee memory fee) pure returns (bool) {
-    return fee.fixedFee == 0 && UFixed.unwrap(fee.fractionalFee) == 0;
-}
+    /// @dev Return the zero fee struct (0, 0)
+    function zeroFee() public pure returns (Fee memory fee) {
+        return Fee(UFixed.wrap(0), 0);
+    }
+
+    // pure free functions for operators
+    function feeIsSame(Fee memory a, Fee memory b) public pure returns (bool isSame) {
+        return a.fixedFee == b.fixedFee && a.fractionalFee == b.fractionalFee;
+    }
+
+    function feeIsZero(Fee memory fee) public pure returns (bool) {
+        return fee.fixedFee == 0 && UFixed.unwrap(fee.fractionalFee) == 0;
+    }
+}

package/contracts/types/Key32.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ObjectType} from "./ObjectType.sol";
+
+type Key32 is bytes32;
+type KeyId is bytes31;
+
+// type bindings
+using {
+    eqKey32 as ==, 
+    neKey32 as !=,
+    Key32Lib.toKey
+} for Key32 global;
+
+// @dev Returns true iff keys are identical
+function eqKey32(Key32 a, Key32 b) pure returns (bool isSame) {
+    return Key32.unwrap(a) == Key32.unwrap(b);
+}
+
+// @dev Returns true iff keys are different
+function neKey32(Key32 a, Key32 b) pure returns (bool isDifferent) {
+    return Key32.unwrap(a) != Key32.unwrap(b);
+}
+
+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
+
+    function toKey32(ObjectType objectType, KeyId id) public pure returns (Key32) {
+        uint256 uintObjectType = ObjectType.unwrap(objectType);
+        uint256 uintId = uint248(KeyId.unwrap(id));
+        uint256 uintKey = (uintObjectType << TYPE_SHIFT) + uintId;
+        return Key32.wrap(bytes32(uintKey));
+    }
+
+    function toKey(Key32 key) public pure returns (ObjectType objectType, KeyId id) {
+        bytes32 key32 = Key32.unwrap(key);
+        objectType = ObjectType.wrap(uint8(uint256(key32 & TYPE_MASK) >> TYPE_SHIFT));
+        id = KeyId.wrap(bytes31((key32 & ID_MASK) << ID_SHIFT));
+    }
+}

package/contracts/types/NftId.sol

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
+import {Key32, KeyId, Key32Lib} from "./Key32.sol";
+import {ObjectType} from "./ObjectType.sol";
+
 // uint96 allows for chain ids up to 13 digits
 type NftId is uint96;
 
@@ -10,7 +13,9 @@ using {
     neNftId as !=, 
     NftIdLib.toInt,
     NftIdLib.gtz,
-    NftIdLib.eqz
+    NftIdLib.eqz,
+    NftIdLib.toKeyId,
+    NftIdLib.toKey32
 } for NftId global;
 
 // general pure free functions
@@ -54,4 +59,14 @@ library NftIdLib {
     function eq(NftId a, NftId b) public pure returns (bool isSame) {
         return eqNftId(a, b);
     }
+
+    /// @dev Returns the key32 value for the specified nft id and object type.
+    function toKey32(NftId id, ObjectType objectType) public pure returns (Key32 key) {
+        return Key32Lib.toKey32(objectType, toKeyId(id));
+    }
+
+    /// @dev Returns the key id value for the specified nft id
+    function toKeyId(NftId id) public pure returns (KeyId keyId) {
+        return KeyId.wrap(bytes31(uint248(NftId.unwrap(id))));
+    }
 }

package/contracts/types/RoleId.sol

@@ -15,15 +15,10 @@ function ORACLE_OWNER_ROLE_NAME() pure returns (string memory) { return "OracleO
 function POOL_OWNER_ROLE_NAME() pure returns (string memory) { return "PoolOwnerRole"; }
 function PRODUCT_OWNER_ROLE_NAME() pure returns (string memory) { return "ProductOwnerRole"; }
 
-function DISTRIBUTOR_OWNER_ROLE() pure returns (RoleId) { return toRoleId("DistributorOwnerRole"); }
-function ORACLE_OWNER_ROLE() pure returns (RoleId) { return toRoleId("OracleOwnerRole"); }
-function POOL_OWNER_ROLE() pure returns (RoleId) { return toRoleId("PoolOwnerRole"); }
-function PRODUCT_OWNER_ROLE() pure returns (RoleId) { return toRoleId("ProductOwnerRole"); }
-
-// @dev Converts a role string into a role id.
-function toRoleId(string memory role) pure returns (RoleId) {
-    return RoleId.wrap(bytes8(keccak256(abi.encode(role))));
-}
+function DISTRIBUTOR_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("DistributorOwnerRole"); }
+function ORACLE_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("OracleOwnerRole"); }
+function POOL_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("PoolOwnerRole"); }
+function PRODUCT_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("ProductOwnerRole"); }
 
 // @dev Returns true iff role ids a and b are identical
 function eqRoleId(RoleId a, RoleId b) pure returns (bool isSame) {
@@ -34,3 +29,10 @@ function eqRoleId(RoleId a, RoleId b) pure returns (bool isSame) {
 function neRoleId(RoleId a, RoleId b) pure returns (bool isDifferent) {
     return RoleId.unwrap(a) != RoleId.unwrap(b);
 }
+
+library RoleIdLib {
+    // @dev Converts a role string into a role id.
+    function toRoleId(string memory role) public pure returns (RoleId) {
+        return RoleId.wrap(bytes8(keccak256(abi.encode(role))));
+    }
+}

package/contracts/types/StateId.sol

@@ -5,7 +5,13 @@ pragma solidity ^0.8.19;
 type StateId is uint8;
 
 // type bindings
-using {eqStateId as ==, neStateId as !=, StateIdLib.toInt} for StateId global;
+using {
+    eqStateId as ==, 
+    neStateId as !=, 
+    StateIdLib.eqz,
+    StateIdLib.gtz,
+    StateIdLib.toInt
+} for StateId global;
 
 // general pure free functions
 function APPLIED() pure returns (StateId) {

package/contracts/types/UFixed.sol

@@ -77,19 +77,25 @@ function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 }
 
 library UFixedMathLib {
-    enum Rounding {
-        /// @dev Round down - floor(value)
-        Down,
-        /// @dev Round up - ceil(value)
-        Up,
-        /// @dev Round half up - round(value)
-        HalfUp
-    }
-
     int8 public constant EXP = 18;
     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 UFixed.
     function toUFixed(uint256 a) public pure returns (UFixed) {
         return UFixed.wrap(a * MULTIPLIER);
@@ -103,9 +109,6 @@ library UFixedMathLib {
         return UFixed.wrap(a * 10 ** uint8(EXP + exp));
     }
 
-    /// @dev Default rounding mode used by ftoi is HalfUp
-    Rounding public constant ROUNDING_DEFAULT = Rounding.HalfUp;
-
     /// @dev returns the decimals precision of the UFixed type
     function decimals() public pure returns (uint256) {
         return uint8(EXP);
@@ -113,12 +116,12 @@ library UFixedMathLib {
 
     /// @dev Converts a UFixed to a uint256.
     function toInt(UFixed a) public pure returns (uint256) {
-        return toIntWithRounding(a, ROUNDING_DEFAULT);
+        return toIntWithRounding(a, ROUNDING_HALF_UP());
     }
 
     /// @dev Converts a UFixed to a uint256 with given rounding mode.
-    function toIntWithRounding(UFixed a, Rounding rounding) public pure returns (uint256) {
-        if (rounding == Rounding.HalfUp) {
+    function toIntWithRounding(UFixed a, uint8 rounding) public pure returns (uint256) {
+        if (rounding == ROUNDING_HALF_UP()) {
             return
                 Math.mulDiv(
                     UFixed.unwrap(a) + MULTIPLIER_HALF,
@@ -126,7 +129,7 @@ library UFixedMathLib {
                     MULTIPLIER,
                     Math.Rounding.Down
                 );
-        } else if (rounding == Rounding.Down) {
+        } else if (rounding == ROUNDING_DOWN()) {
             return
                 Math.mulDiv(
                     UFixed.unwrap(a),