npm - @etherisc/gif-next - Versions diffs - 0.0.2-d911522 → 0.0.2-d93d2dc-010 - Mend

@etherisc/gif-next 0.0.2-d911522 → 0.0.2-d93d2dc-010

Files changed (618) hide show

package/contracts/instance/pool/PoolModule.sol DELETED Viewed

@@ -1,86 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
-import {IProductService} from "../product/IProductService.sol";
-import {IPolicy, IPolicyModule} from "../policy/IPolicy.sol";
-import {IPoolModule} from "./IPoolModule.sol";
-import {NftId, NftIdLib} from "../../types/NftId.sol";
-abstract contract PoolModule is
-    IPoolModule
-{
-    using NftIdLib for NftId;
-    uint256 public constant INITIAL_CAPITAL = 10000*10**6;
-    mapping(NftId nftId => PoolInfo info) private _poolInfo;
-    IProductService private _productService;
-    modifier onlyProductService() {
-        require(address(_productService) == msg.sender, "ERROR:POL-001:NOT_PRODUCT_SERVICE");
-        _;
-    }
-    constructor(address productService) {
-        _productService = IProductService(productService);
-    }
-    function createPoolInfo(
-        NftId nftId,
-        address wallet,
-        address token
-    )
-        public
-        override
-    {
-        require(
-            _poolInfo[nftId].nftId.eqz(),
-            "ERROR:PL-001:ALREADY_CREATED");
-        _poolInfo[nftId] = PoolInfo(
-            nftId,
-            wallet,
-            token,
-            INITIAL_CAPITAL,
-            0 // locked capital
-        );
-    }
-    function underwrite(
-        NftId poolNftId,
-        NftId policyNftId
-    )
-        external
-        override
-        onlyProductService
-    {
-        PoolInfo storage poolInfo = _poolInfo[poolNftId];
-        require(
-            poolInfo.nftId == poolNftId,
-            "ERROR:PL-002:POOL_UNKNOWN");
-        IPolicyModule policyModule = IPolicyModule(address(this));
-        IPolicy.PolicyInfo memory policyInfo = policyModule.getPolicyInfo(policyNftId);
-        require(
-            poolInfo.capital - poolInfo.lockedCapital >= policyInfo.sumInsuredAmount,
-            "ERROR:PL-003:CAPACITY_TOO_LOW");
-        poolInfo.lockedCapital += policyInfo.sumInsuredAmount;
-    }
-    function getPoolInfo(NftId nftId)
-        external
-        view
-        override
-        returns(PoolInfo memory info)
-    {
-        info = _poolInfo[nftId];
-    }
-}

package/contracts/instance/product/IProductService.sol DELETED Viewed

@@ -1,46 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
-import {IInstance} from "../IInstance.sol";
-import {NftId} from "../../types/NftId.sol";
-// TODO or name this IProtectionService to have Product be something more generic (loan, savings account, ...)
-interface IProductService is
-    IRegistryLinked
-{
-    function createApplication(
-        address applicationOwner,
-        uint256 sumInsuredAmount,
-        uint256 premiumAmount,
-        uint256 lifetime,
-        NftId bundleNftId
-    )
-        external
-        returns(NftId nftId);
-    // function revoke(unit256 nftId) external;
-    function underwrite(NftId nftId) external;
-    // function decline(uint256 nftId) external;
-    // function expire(uint256 nftId) external;
-    function close(NftId nftId) external;
-    // function collectPremium(uint256 nftId, uint256 premiumAmount) external;
-    // function createClaim(uint256 nftId, uint256 claimAmount) external;
-    // function confirmClaim(uint256 nftId, uint256 claimId, uint256 claimAmount) external;
-    // function declineClaim(uint256 nftId, uint256 claimId) external;
-    // function closeClaim(uint256 nftId, uint256 claimId) external;
-}
-interface IProductModule is
-    IOwnable,
-    IRegistryLinked
-{
-    function getProductService() external view returns(IProductService);
-}

package/contracts/instance/product/ProductService.sol DELETED Viewed

@@ -1,108 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-// import {IProduct} from "../../components/IProduct.sol";
-// import {IOwnable, IRegistryLinked, IRegisterable, IRegistry} from "../../registry/IRegistry.sol";
-// import {IInstance} from "../IInstance.sol";
-import {IRegistry} from "../../registry/IRegistry.sol";
-import {IPolicyModule} from "../policy/IPolicy.sol";
-import {RegistryLinked} from "../../registry/Registry.sol";
-import {IProductService, IProductModule} from "./IProductService.sol";
-import {IComponentModule} from "../../instance/component/IComponent.sol";
-import {IPoolModule} from "../../instance/pool/IPoolModule.sol";
-import {NftId, NftIdLib} from "../../types/NftId.sol";
-// TODO or name this ProtectionService to have Product be something more generic (loan, savings account, ...)
-contract ProductService is
-    RegistryLinked,
-    IProductService
-{
-    using NftIdLib for NftId;
-    constructor(address registry)
-        RegistryLinked(registry)
-    { }
-    function createApplication(
-        address applicationOwner,
-        uint256 sumInsuredAmount,
-        uint256 premiumAmount,
-        uint256 lifetime,
-        NftId bundleNftId
-    )
-        external
-        override
-        returns(NftId nftId)
-    {
-        // same as only registered product
-        NftId productNftId = _registry.getNftId(msg.sender);
-        require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
-        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(productNftId);
-        require(productInfo.objectType == _registry.PRODUCT(), "ERROR_NOT_PRODUCT");
-        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
-        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
-        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
-        IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
-        nftId = policyModule.createApplication(
-            productInfo,
-            applicationOwner,
-            sumInsuredAmount,
-            premiumAmount,
-            lifetime,
-            bundleNftId);
-        // add logging
-    }
-    function underwrite(NftId nftId)
-        external
-        override
-    {
-        // same as only registered product
-        NftId productNftId = _registry.getNftId(msg.sender);
-        require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
-        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(productNftId);
-        require(productInfo.objectType == _registry.PRODUCT(), "ERROR_NOT_PRODUCT");
-        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
-        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
-        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
-        // get responsible pool
-        IComponentModule componentModule = IComponentModule(instanceInfo.objectAddress);
-        NftId poolNftId = componentModule.getPoolNftId(productNftId);
-        // lock capital (and update pool accounting)
-        IPoolModule poolModule = IPoolModule(instanceInfo.objectAddress);
-        poolModule.underwrite(
-            poolNftId,
-            nftId);
-        // activate policy
-        IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
-        policyModule.activate(nftId);
-        // add logging
-    }
-    function close(NftId nftId) external override {}
-}
-abstract contract ProductModule is
-    IProductModule
-{
-    IProductService private _productService;
-    constructor(address productService) {
-        _productService = IProductService(productService);
-    }
-    function getProductService() external view returns(IProductService) {
-        return _productService;
-    }
-}

package/contracts/registry/IChainNft.sol DELETED Viewed

@@ -1,18 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-import {IERC721Enumerable} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
-interface IChainNft is
-    IERC721Enumerable
-{
-    function mint(address to, string memory uri) external returns(uint256 tokenId);
-    function burn(uint256 tokenId) external;
-    function setURI(uint256 tokenId, string memory uri) external;
-    function exists(uint256 tokenId) external view returns(bool);
-    function totalMinted() external view returns(uint256);
-    function getRegistryAddress() external view returns(address registry);
-}

package/contracts/types/Blocknumber.sol DELETED Viewed

@@ -1,60 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-type Blocknumber is uint32;
-using {
-    gtBlocknumber as >,
-    gteBlocknumber as >=,
-    ltBlocknumber as <,
-    lteBlocknumber as <=,
-    eqBlocknumber as ==,
-    neBlocknumber as !=,
-    BlocknumberLib.toInt
-} for Blocknumber global;
-/// @dev return true if Blocknumber a is greater than Blocknumber b
-function gtBlocknumber(Blocknumber a, Blocknumber b) pure returns(bool) { return Blocknumber.unwrap(a) > Blocknumber.unwrap(b); }
-/// @dev return true if Blocknumber a is greater than or equal to Blocknumber b
-function gteBlocknumber(Blocknumber a, Blocknumber b) pure returns(bool) { return Blocknumber.unwrap(a) >= Blocknumber.unwrap(b); }
-/// @dev return true if Blocknumber a is less than Blocknumber b
-function ltBlocknumber(Blocknumber a, Blocknumber b) pure returns(bool) { return Blocknumber.unwrap(a) < Blocknumber.unwrap(b); }
-/// @dev return true if Blocknumber a is less than or equal to Blocknumber b
-function lteBlocknumber(Blocknumber a, Blocknumber b) pure returns(bool) { return Blocknumber.unwrap(a) <= Blocknumber.unwrap(b); }
-/// @dev return true if Blocknumber a is equal to Blocknumber b
-function eqBlocknumber(Blocknumber a, Blocknumber b) pure returns(bool) { return Blocknumber.unwrap(a) == Blocknumber.unwrap(b); }
-/// @dev return true if Blocknumber a is not equal to Blocknumber b
-function neBlocknumber(Blocknumber a, Blocknumber b) pure returns(bool) { return Blocknumber.unwrap(a) != Blocknumber.unwrap(b); }
-/// @dev Converts the uint256 to a Blocknumber.
-function toBlocknumber(uint256 blocknum) pure returns(Blocknumber) { return Blocknumber.wrap(uint32(blocknum)); }
-function blockBlocknumber() view returns(Blocknumber) { return toBlocknumber(block.number); }
-/// @dev Return the Blocknumber zero (0)
-function zeroBlocknumber() pure returns(Blocknumber) { return toBlocknumber(0); }
-/// @dev Return the current block number
-function blockNumber() view returns(Blocknumber) { return toBlocknumber(block.number); }
-library BlocknumberLib {
-    /// @dev return true if Blocknumber a is greater than Blocknumber b
-    function gt(Blocknumber a, Blocknumber b) public pure returns(bool isAfter) { return gtBlocknumber(a, b); }
-    /// @dev return true if Blocknumber a is greater than or equal to Blocknumber b
-    function gte(Blocknumber a, Blocknumber b) public pure returns(bool isAfterOrSame) { return gteBlocknumber(a, b); }
-    /// @dev return true if Blocknumber a is less than Blocknumber b
-    function lt(Blocknumber a, Blocknumber b) public pure returns(bool isBefore) { return ltBlocknumber(a, b); }
-    /// @dev return true if Blocknumber a is less than or equal to Blocknumber b
-    function lte(Blocknumber a, Blocknumber b) public pure returns(bool isBeforeOrSame) { return lteBlocknumber(a, b); }
-    /// @dev return true if Blocknumber a is equal to Blocknumber b
-    function eq(Blocknumber a, Blocknumber b) public pure returns(bool isSame) { return eqBlocknumber(a, b); }
-    /// @dev return true if Blocknumber a is not equal to Blocknumber b
-    function ne(Blocknumber a, Blocknumber b) public pure returns(bool isDifferent) { return neBlocknumber(a, b); }
-    /// @dev converts the Blocknumber to a uint256
-    function toInt(Blocknumber blocknumber) public pure returns(uint256) { return uint256(uint32(Blocknumber.unwrap(blocknumber))); }
-}

package/contracts/types/ChainId.sol DELETED Viewed

@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-/// @dev bytes5 (uint40) allows for chain ids up to 13 digits
-type ChainId is bytes5;
-// type bindings
-using {
-    eqChainId as ==,
-    neChainId as !=,
-    ChainIdLib.toInt
-} for ChainId global;
-// general pure free functions
-/// @dev Converts the uint256 to a ChainId.
-function toChainId(uint256 chainId) pure returns(ChainId) { return ChainId.wrap(bytes5(uint40(chainId))); }
-/// @dev Return the ChainId for the chain the contract is deployed to
-function thisChainId() view returns(ChainId) { return toChainId(block.chainid); }
-// pure free functions for operators
-/// @dev Returns true if the values are equal (==).
-function eqChainId(ChainId a, ChainId b) pure returns(bool isSame) { return ChainId.unwrap(a) == ChainId.unwrap(b); }
-/// @dev Returns true if the values are not equal (!=).
-function neChainId(ChainId a, ChainId b) pure returns(bool isDifferent) { return ChainId.unwrap(a) != ChainId.unwrap(b); }
-// library functions that operate on user defined type
-library ChainIdLib {
-    /// @dev Converts the ChainId to a uint256.
-    function toInt(ChainId chainId) internal pure returns(uint256) { return uint256(uint40(ChainId.unwrap(chainId))); }
-}

package/contracts/types/NftId.sol DELETED Viewed

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-// uint96 allows for chain ids up to 13 digits
-type NftId is uint96;
-// type bindings
-using {
-    eqNftId as ==,
-    neNftId as !=,
-    NftIdLib.toInt
-} for NftId global;
-// general pure free functions
-/// @dev Converts the uint256 to a NftId.
-function toNftId(uint256 id) pure returns(NftId) { return NftId.wrap(uint96(id)); }
-/// @dev Return the NftId zero (0)
-function zeroNftId() pure returns(NftId) { return NftId.wrap(0); }
-// pure free functions for operators
-function eqNftId(NftId a, NftId b) pure returns(bool isSame) { return NftId.unwrap(a) == NftId.unwrap(b); }
-function neNftId(NftId a, NftId b) pure returns(bool isDifferent) { return NftId.unwrap(a) != NftId.unwrap(b); }
-// library functions that operate on user defined type
-library NftIdLib {
-    /// @dev Converts the NftId to a uint256.
-    function toInt(NftId nftId) public pure returns(uint96) { return uint96(NftId.unwrap(nftId)); }
-    /// @dev Returns true if the value is non-zero (> 0).
-    function gtz(NftId a) public pure returns(bool) { return NftId.unwrap(a) > 0; }
-    /// @dev Returns true if the value is zero (== 0).
-    function eqz(NftId a) public pure returns(bool) { return NftId.unwrap(a) == 0; }
-    /// @dev Returns true if the values are equal (==).
-    function eq(NftId a, NftId b) public pure returns(bool isSame) { return eqNftId(a, b); }
-}

package/contracts/types/Timestamp.sol DELETED Viewed

@@ -1,55 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-type Timestamp is uint40;
-using {
-    gtTimestamp as >,
-    gteTimestamp as >=,
-    ltTimestamp as <,
-    lteTimestamp as <=,
-    eqTimestamp as ==,
-    neTimestamp as !=
-} for Timestamp global;
-/// @dev return true if Timestamp a is after Timestamp b
-function gtTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) > Timestamp.unwrap(b); }
-/// @dev return true if Timestamp a is after or equal to Timestamp b
-function gteTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) >= Timestamp.unwrap(b); }
-/// @dev return true if Timestamp a is before Timestamp b
-function ltTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) < Timestamp.unwrap(b); }
-/// @dev return true if Timestamp a is before or equal to Timestamp b
-function lteTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) <= Timestamp.unwrap(b); }
-/// @dev return true if Timestamp a is equal to Timestamp b
-function eqTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) == Timestamp.unwrap(b); }
-/// @dev return true if Timestamp a is not equal to Timestamp b
-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); }
-/// @dev Return the Timestamp zero (0)
-function zeroTimestamp() pure returns(Timestamp) { return toTimestamp(0); }
-library TimestampLib {
-    /// @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); }
-    /// @dev return true if Timestamp a is after or the same than Timestamp b
-    function gte(Timestamp a, Timestamp b) public pure returns(bool isAfterOrSame) { return gteTimestamp(a, b); }
-    /// @dev return true if Timestamp a is before Timestamp b
-    function lt(Timestamp a, Timestamp b) public pure returns(bool isBefore) { return ltTimestamp(a, b); }
-    /// @dev return true if Timestamp a is before or the same than Timestamp b
-    function lte(Timestamp a, Timestamp b) public pure returns(bool isBeforeOrSame) { return lteTimestamp(a, b); }
-    /// @dev return true if Timestamp a is equal to Timestamp b
-    function eq(Timestamp a, Timestamp b) public pure returns(bool isSame) { return eqTimestamp(a, b); }
-    /// @dev return true if Timestamp a is not equal to Timestamp b
-    function ne(Timestamp a, Timestamp b) public pure returns(bool isDifferent) { return neTimestamp(a, b); }
-    function toInt(Timestamp timestamp) public pure returns(uint256) { return uint256(uint40(Timestamp.unwrap(timestamp))); }
-}

package/contracts/types/UFixed.sol DELETED Viewed

@@ -1,207 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
-/// @dev UFixed is a fixed point number with 18 decimals precision.
-type UFixed is uint256;
-using {
-    addUFixed as +,
-    subUFixed as -,
-    mulUFixed as *,
-    divUFixed as /,
-    gtUFixed as >,
-    gteUFixed as >=,
-    ltUFixed as <,
-    lteUFixed as <=,
-    eqUFixed as ==
-} for UFixed global;
-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");
-    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));
-}
-function divUFixed(UFixed a, UFixed b) pure returns(UFixed) {
-    require(UFixed.unwrap(b) > 0, "ERROR:UFM-020:DIVISOR_ZERO");
-    return UFixed.wrap(
-        Math.mulDiv(
-            UFixed.unwrap(a),
-            10 ** 18,
-            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 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 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 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);
-    }
-    /// @dev Converts the uint256 to a UFixed.
-    function itof(uint256 a)
-        public
-        pure
-        returns(UFixed)
-    {
-        return UFixed.wrap(a * MULTIPLIER);
-    }
-    /// @dev Converts the uint256 to a UFixed with given exponent.
-    function itof(uint256 a, int8 exp)
-        public
-        pure
-        returns(UFixed)
-    {
-        require(EXP + exp >= 0, "ERROR:FM-010:EXPONENT_TOO_SMALL");
-        require(EXP + exp <= 2 * EXP, "ERROR:FM-011:EXPONENT_TOO_LARGE");
-        return UFixed.wrap(a * 10 ** uint8(EXP + exp));
-    }
-    /// @dev Converts a UFixed to a uint256.
-    function ftoi(UFixed a)
-        public
-        pure
-        returns(uint256)
-    {
-        return ftoi(a, ROUNDING_DEFAULT);
-    }
-    /// @dev Converts a UFixed to a uint256 with given rounding mode.
-    function ftoi(UFixed a, Rounding rounding)
-        public
-        pure
-        returns(uint256)
-    {
-        if(rounding == Rounding.HalfUp) {
-            return Math.mulDiv(UFixed.unwrap(a) + MULTIPLIER_HALF, 1, MULTIPLIER, Math.Rounding.Down);
-        } else if(rounding == Rounding.Down) {
-            return Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Down);
-        } else {
-            return Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Up);
-        }
-    }
-    /// @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);
-    }
-    /// @dev return the absolute delta between two UFixed numbers
-    function delta(UFixed a, UFixed b) public pure returns(UFixed) {
-        return deltaUFixed(a, b);
-    }
-}