@etherisc/gif-next 0.0.2-863825a-972 → 0.0.2-864c5f3-808

package/contracts/distribution/DistributionService.sol

@@ -0,0 +1,368 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccountingService} from "../accounting/IAccountingService.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
+import {IDistribution} from "../instance/module/IDistribution.sol";
+import {IDistributionService} from "./IDistributionService.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
+import {DistributorType, DistributorTypeLib} from "../type/DistributorType.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {KEEP_STATE} from "../type/StateId.sol";
+import {ObjectType, ACCOUNTING, COMPONENT, DISTRIBUTION, INSTANCE, DISTRIBUTION, DISTRIBUTOR, REGISTRY} from "../type/ObjectType.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
+import {ReferralId, ReferralLib} from "../type/Referral.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+import {UFixed} from "../type/UFixed.sol";
+
+
+contract DistributionService is
+    ComponentVerifyingService,
+    IDistributionService
+{
+    IAccountingService private _accountingService;
+    IComponentService private _componentService;
+    IInstanceService private _instanceService;
+    IRegistryService private _registryService;
+    
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        virtual override
+        initializer()
+    {
+        (
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
+
+        __Service_init(authority, registry, owner);
+
+        _accountingService = IAccountingService(_getServiceAddress(ACCOUNTING()));
+        _componentService = IComponentService(_getServiceAddress(COMPONENT()));
+        _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
+        _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
+
+        _registerInterface(type(IDistributionService).interfaceId);
+    }
+
+
+    function createDistributorType(
+        string memory name,
+        UFixed minDiscountPercentage,
+        UFixed maxDiscountPercentage,
+        UFixed commissionPercentage,
+        uint32 maxReferralCount,
+        Seconds maxReferralLifetime,
+        bool allowSelfReferrals,
+        bool allowRenewals,
+        bytes memory data
+    )
+        external
+        returns (DistributorType distributorType)
+    {
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
+        // InstanceReader instanceReader = instance.getInstanceReader();
+
+        {
+            NftId productNftId = _getProductNftId(distributionNftId);
+            IComponents.FeeInfo memory feeInfo = instance.getInstanceReader().getFeeInfo(productNftId);
+
+            UFixed variableDistributionFees = feeInfo.distributionFee.fractionalFee;
+            UFixed variableFeesPartsTotal = feeInfo.minDistributionOwnerFee.fractionalFee + commissionPercentage;
+
+            if (variableFeesPartsTotal > variableDistributionFees) {
+                revert ErrorDistributionServiceVariableFeesTooHight(variableDistributionFees.toInt1000(), variableFeesPartsTotal.toInt1000());
+            }
+            UFixed maxDiscountPercentageLimit = variableDistributionFees - variableFeesPartsTotal;
+
+            if (maxDiscountPercentage.gt(maxDiscountPercentageLimit)) {
+                revert ErrorDistributionServiceMaxDiscountTooHigh(maxDiscountPercentage.toInt1000(), maxDiscountPercentageLimit.toInt1000());
+            }
+        }
+
+        distributorType = DistributorTypeLib.toDistributorType(distributionNftId, name);
+        IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo(
+            name,
+            distributionNftId,
+            minDiscountPercentage,
+            maxDiscountPercentage,
+            commissionPercentage,
+            maxReferralCount,
+            maxReferralLifetime,
+            allowSelfReferrals,
+            allowRenewals,
+            data);
+
+        instance.getInstanceStore().createDistributorType(distributorType, info);
+    }
+
+
+    function createDistributor(
+        address distributor,
+        DistributorType distributorType,
+        bytes memory data
+    )
+        external 
+        virtual
+        returns (NftId distributorNftId)
+    {
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
+
+        {
+            NftId expectedDistributionNftId = instance.getInstanceReader().getDistributorTypeInfo(distributorType).distributionNftId;
+
+            if (distributionNftId != expectedDistributionNftId) {
+                revert ErrorDistributionServiceInvalidDistributorType(distributorType);
+            }
+        }
+
+        distributorNftId = _registryService.registerDistributor(
+            IRegistry.ObjectInfo(
+                NftIdLib.zero(), 
+                distributionNftId,
+                DISTRIBUTOR(),
+                true, // intercepting property for bundles is defined on pool
+                address(0),
+                distributor,
+                ""
+            ));
+
+        IDistribution.DistributorInfo memory info = IDistribution.DistributorInfo(
+            distributorType,
+            true, // active
+            data,
+            0);
+
+        instance.getInstanceStore().createDistributor(distributorNftId, info);
+    }
+
+    function changeDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    )
+        external
+        virtual
+    {
+        (,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
+        IDistribution.DistributorInfo memory distributorInfo = instance.getInstanceReader().getDistributorInfo(distributorNftId);
+        distributorInfo.distributorType = distributorType;
+        distributorInfo.data = data;
+        instance.getInstanceStore().updateDistributor(distributorNftId, distributorInfo, KEEP_STATE());
+    }
+
+
+    function createReferral(
+        NftId distributorNftId,
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    )
+        external
+        virtual
+        onlyNftOfType(distributorNftId, DISTRIBUTOR())
+        returns (ReferralId referralId)
+    {
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
+
+        if (bytes(code).length == 0) {
+            revert ErrorDistributionServiceInvalidReferral(code);
+        }
+        if (expiryAt.eqz() || expiryAt.lte(TimestampLib.blockTimestamp())) {
+            revert ErrorDistributionServiceExpirationInvalid(expiryAt);
+        }
+
+        {
+            InstanceReader instanceReader = instance.getInstanceReader();
+            DistributorType distributorType = instanceReader.getDistributorInfo(distributorNftId).distributorType;
+            IDistribution.DistributorTypeInfo memory distributorTypeData = instanceReader.getDistributorTypeInfo(distributorType);
+
+            if (distributorTypeData.maxReferralCount < maxReferrals) {
+                revert ErrorDistributionServiceMaxReferralsExceeded(distributorTypeData.maxReferralCount);
+            }
+            if (distributorTypeData.minDiscountPercentage > discountPercentage) {
+                revert ErrorDistributionServiceDiscountTooLow(distributorTypeData.minDiscountPercentage.toInt(), discountPercentage.toInt());
+            }
+            if (distributorTypeData.maxDiscountPercentage < discountPercentage) {
+                revert ErrorDistributionServiceDiscountTooHigh(distributorTypeData.maxDiscountPercentage.toInt(), discountPercentage.toInt());
+            }
+            if (expiryAt.toInt() - TimestampLib.blockTimestamp().toInt() > distributorTypeData.maxReferralLifetime.toInt()) {
+                revert ErrorDistributionServiceExpiryTooLong(distributorTypeData.maxReferralLifetime, expiryAt);
+            }
+        }
+
+        {
+            referralId = ReferralLib.toReferralId(distributionNftId, code);
+            IDistribution.ReferralInfo memory info = IDistribution.ReferralInfo(
+                distributionNftId,
+                distributorNftId,
+                code,
+                discountPercentage,
+                maxReferrals,
+                0, // used referrals
+                expiryAt,
+                data
+            );
+
+            instance.getInstanceStore().createReferral(referralId, info);
+        }
+    }
+
+    /// @inheritdoc IDistributionService
+    function processReferral(
+        NftId distributionNftId, 
+        ReferralId referralId
+    ) 
+        external
+        virtual
+        restricted()
+        onlyNftOfType(distributionNftId, DISTRIBUTION())
+    {
+        if (referralIsValid(distributionNftId, referralId)) {
+            IRegistry registry = getRegistry();
+            IRegistry.ObjectInfo memory distributionInfo = registry.getObjectInfo(distributionNftId);
+            IInstance instance = _getInstanceForComponent(registry, distributionInfo.parentNftId);
+
+            // update book keeping for referral info
+            IDistribution.ReferralInfo memory referralInfo = instance.getInstanceReader().getReferralInfo(referralId);
+            referralInfo.usedReferrals += 1;
+            instance.getInstanceStore().updateReferral(referralId, referralInfo, KEEP_STATE());
+        }
+    }
+
+    function processSale(
+        NftId distributionNftId, // assume always of distribution type
+        ReferralId referralId,
+        IPolicy.PremiumInfo memory premium
+    )
+        external
+        virtual
+        restricted()
+        onlyNftOfType(distributionNftId, DISTRIBUTION())
+    {
+        IRegistry registry = getRegistry();
+        IRegistry.ObjectInfo memory distributionInfo = registry.getObjectInfo(distributionNftId);
+        IInstance instance = _getInstanceForComponent(registry, distributionInfo.parentNftId);
+        InstanceReader reader = instance.getInstanceReader();
+        InstanceStore store = instance.getInstanceStore();
+
+        // get distribution owner fee amount
+        Amount distributionOwnerFee = premium.distributionOwnerFeeFixAmount + premium.distributionOwnerFeeVarAmount;
+
+        // update referral/distributor info if applicable
+        if (referralIsValid(distributionNftId, referralId)) {
+
+            // increase distribution balance by commission amount and distribution owner fee
+            Amount commissionAmount = premium.commissionAmount;
+            _accountingService.increaseDistributionBalance(store, distributionNftId, commissionAmount, distributionOwnerFee);
+
+            // update book keeping for referral info
+            IDistribution.ReferralInfo memory referralInfo = reader.getReferralInfo(referralId);
+
+            _accountingService.increaseDistributorBalance(store, referralInfo.distributorNftId, AmountLib.zero(), commissionAmount);
+
+            // update book keeping for distributor info
+            IDistribution.DistributorInfo memory distributorInfo = reader.getDistributorInfo(referralInfo.distributorNftId);
+            distributorInfo.numPoliciesSold += 1;
+            store.updateDistributor(referralInfo.distributorNftId, distributorInfo, KEEP_STATE());
+        } else {
+            // increase distribution balance by distribution owner fee
+            _accountingService.increaseDistributionBalance(store, distributionNftId, AmountLib.zero(), distributionOwnerFee);
+        }
+    }
+
+    /// @inheritdoc IDistributionService
+    function withdrawCommission(NftId distributorNftId, Amount amount) 
+        public 
+        virtual
+        // TODO: restricted() (once #462 is done)
+        onlyNftOfType(distributorNftId, DISTRIBUTOR())
+        returns (Amount withdrawnAmount) 
+    {
+        (NftId distributionNftId,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
+        InstanceReader reader = instance.getInstanceReader();
+        
+        IComponents.ComponentInfo memory distributionInfo = reader.getComponentInfo(distributionNftId);
+        address distributionWallet = distributionInfo.tokenHandler.getWallet();
+        
+        Amount commissionAmount = reader.getFeeAmount(distributorNftId);
+        
+        // determine withdrawn amount
+        withdrawnAmount = amount;
+        if (withdrawnAmount.gte(AmountLib.max())) {
+            withdrawnAmount = commissionAmount;
+        } else {
+            if (withdrawnAmount.gt(commissionAmount)) {
+                revert ErrorDistributionServiceCommissionWithdrawAmountExceedsLimit(withdrawnAmount, commissionAmount);
+            }
+        }
+
+        // decrease fee counters by withdrawnAmount and update distributor info
+        {
+            InstanceStore store = instance.getInstanceStore();
+            // decrease fee counter for distribution balance
+            _accountingService.decreaseDistributionBalance(store, distributionNftId, withdrawnAmount, AmountLib.zero());
+            // decrease fee counter for distributor fee
+            _accountingService.decreaseDistributorBalance(store, distributorNftId, AmountLib.zero(), withdrawnAmount);
+        }
+
+        // transfer amount to distributor
+        {
+            address distributor = getRegistry().ownerOf(distributorNftId);
+            emit LogDistributionServiceCommissionWithdrawn(distributorNftId, distributor, address(distributionInfo.token), withdrawnAmount);
+            distributionInfo.tokenHandler.pushToken(distributor, withdrawnAmount);
+        }
+    }
+
+    function referralIsValid(NftId distributionNftId, ReferralId referralId) 
+        public 
+        view 
+        onlyNftOfType(distributionNftId, DISTRIBUTION())
+        returns (bool isValid) 
+    {
+        if (distributionNftId.eqz() || referralId.eqz()) {
+            return false;
+        }
+
+        IRegistry registry = getRegistry();
+        IRegistry.ObjectInfo memory distributionInfo = registry.getObjectInfo(distributionNftId);
+        IInstance instance = _getInstanceForComponent(registry, distributionInfo.parentNftId);
+        IDistribution.ReferralInfo memory info = instance.getInstanceReader().getReferralInfo(referralId);
+
+        if (info.distributorNftId.eqz()) {
+            return false;
+        }
+
+        isValid = info.expiryAt.eqz() || (info.expiryAt.gtz() && TimestampLib.blockTimestamp() <= info.expiryAt);
+        isValid = isValid && info.usedReferrals < info.maxReferrals;
+    }
+
+    function _getInstanceForDistribution(NftId distributionNftId)
+        internal
+        view
+        returns(IInstance instance)
+    {
+        NftId instanceNftId = getRegistry().getParentNftId(distributionNftId);
+        address instanceAddress = getRegistry().getObjectAddress(instanceNftId);
+        return IInstance(instanceAddress);
+    }
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return DISTRIBUTION();
+    }
+}

package/contracts/distribution/DistributionServiceManager.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
+import {DistributionService} from "./DistributionService.sol";
+
+contract DistributionServiceManager is ProxyManager {
+
+    DistributionService private _distributionService;
+
+    /// @dev initializes proxy manager with distribution service implementation and deploys instance
+    constructor(
+        address authority, 
+        address registry,
+        bytes32 salt
+    ) 
+    {
+        DistributionService svc = new DistributionService{salt: salt}();
+        bytes memory data = abi.encode(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
+            address(svc), 
+            data,
+            salt);
+
+        _distributionService = DistributionService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getDistributionService()
+        external
+        view
+        returns (DistributionService distributionService)
+    {
+        return _distributionService;
+    }
+
+}

package/contracts/distribution/IDistributionComponent.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {NftId} from "../type/NftId.sol";
+import {ReferralId, ReferralStatus} from "../type/Referral.sol";
+import {UFixed} from "../type/UFixed.sol";
+
+interface IDistributionComponent is IInstanceLinkedComponent {
+
+    error ErrorDistributionNotDistributor(address distributor);
+    error ErrorDistributionAlreadyDistributor(address distributor, NftId distributorNftId);
+
+    event LogDistributorUpdated(address to, address operator);
+
+    /// @dev Returns true iff the provided address is registered as a distributor with this distribution component.
+    function isDistributor(address candidate) external view returns (bool);
+
+    /// @dev Returns the distributor Nft Id for the provided address
+    function getDistributorNftId(address distributor) external view returns (NftId distributorNftId);
+
+    function getDiscountPercentage(
+        string memory referralCode
+    ) external view returns (UFixed discountPercentage, ReferralStatus status);
+
+    function getReferralId(
+        string memory referralCode
+    ) external returns (ReferralId referralId);
+
+    function calculateRenewalFeeAmount(
+        ReferralId referralId,
+        uint256 netPremiumAmount
+    ) external view returns (uint256 feeAmount);
+
+    /// @dev Callback function to process a renewal of a policy.
+    /// The default implementation is empty.
+    /// Overwrite this function to implement a use case specific behaviour.
+    function processRenewal(
+        ReferralId referralId,
+        uint256 feeAmount
+    ) external;
+
+    /// @dev Returns true to ensure component is called when transferring distributor Nft Ids.
+    function isVerifying() external view returns (bool verifying);
+
+    /// @dev Withdraw commission for the distributor
+    /// @param distributorNftId the distributor Nft Id
+    /// @param amount the amount to withdraw. If set to AMOUNT_MAX, the full commission available is withdrawn
+    /// @return withdrawnAmount the effective withdrawn amount
+    function withdrawCommission(NftId distributorNftId, Amount amount) external returns (Amount withdrawnAmount);
+}

package/contracts/distribution/IDistributionService.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {NftId} from "../type/NftId.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IService} from "../shared/IService.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+interface IDistributionService is IService {
+
+    error ErrorDistributionServiceInvalidDistributorType(DistributorType distributorType);
+    error ErrorDistributionServiceCallerNotRegistered(address caller);
+    error ErrorDistributionServiceParentNftIdNotInstance(NftId nftId, NftId parentNftId);
+    error ErrorDistributionServiceCallerNotDistributor(address caller);
+    error ErrorDistributionServiceInvalidReferralId(ReferralId referralId);
+    error ErrorDistributionServiceMaxReferralsExceeded(uint256 maxReferrals);
+    error ErrorDistributionServiceDiscountTooLow(uint256 minDiscountPercentage, uint256 discountPercentage);
+    error ErrorDistributionServiceDiscountTooHigh(uint256 maxDiscountPercentage, uint256 discountPercentage);
+    error ErrorDistributionServiceExpiryTooLong(Seconds maxReferralLifetime, Timestamp expiryAt);
+    error ErrorDistributionServiceInvalidReferral(string code);
+    error ErrorDistributionServiceExpirationInvalid(Timestamp expiryAt);
+    error ErrorDistributionServiceCommissionTooHigh(uint256 commissionPercentage, uint256 maxCommissionPercentage);
+    error ErrorDistributionServiceMinFeeTooHigh(uint256 minFee, uint256 limit);
+
+    error ErrorDistributionServiceCommissionWithdrawAmountExceedsLimit(Amount amount, Amount limit);
+    
+    error ErrorDistributionServiceVariableFeesTooHight(uint256 maxDiscountPercentage, uint256 limit);
+    error ErrorDistributionServiceMaxDiscountTooHigh(uint256 maxDiscountPercentage, uint256 limit);
+
+    error ErrorDistributionServiceReferralInvalid(NftId distributionNftId, ReferralId referralId);
+    error ErrorDistributionServiceInvalidFeeTransferred(Amount transferredDistributionFeeAmount, Amount expectedDistributionFeeAmount);
+
+    event LogDistributionServiceCommissionWithdrawn(NftId distributorNftId, address recipient, address tokenAddress, Amount amount);
+
+    function createDistributorType(
+        string memory name,
+        UFixed minDiscountPercentage,
+        UFixed maxDiscountPercentage,
+        UFixed commissionPercentage,
+        uint32 maxReferralCount,
+        Seconds maxReferralLifetime,
+        bool allowSelfReferrals,
+        bool allowRenewals,
+        bytes memory data
+    )
+        external
+        returns (DistributorType distributorType);
+
+    function createDistributor(
+        address distributor,
+        DistributorType distributorType,
+        bytes memory data
+    ) external returns (NftId distributorNftId);
+
+    function changeDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    ) external;
+
+    function createReferral(
+        NftId distributorNftId,
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    )
+        external
+        returns (ReferralId referralId);
+
+    /// @dev callback from product service when a referral is used. 
+    /// Calling this will increment the referral usage counter. 
+    function processReferral(
+        NftId distributionNftId, 
+        ReferralId referralId
+    ) external;
+
+    /// @dev callback from product service when selling a policy for a specific referralId
+    function processSale(
+        NftId distributionNftId,
+        ReferralId referralId,
+        IPolicy.PremiumInfo memory premium
+    ) external;
+
+    function referralIsValid(
+        NftId distributorNftId,
+        ReferralId referralId
+    ) external view returns (bool isValid);
+
+    /// @dev Withdraw commission for the distributor
+    /// @param distributorNftId the distributor Nft Id
+    /// @param amount the amount to withdraw. If set to AMOUNT_MAX, the full commission available is withdrawn
+    /// @return withdrawnAmount the effective withdrawn amount
+    function withdrawCommission(NftId distributorNftId, Amount amount) external returns (Amount withdrawnAmount);
+}

package/contracts/examples/fire/DamageLevel.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+type DamageLevel is uint8;
+
+// type bindings
+using {
+    DamageLevelLib.eq,
+    DamageLevelLib.eqz,
+    DamageLevelLib.toInt
+} for DamageLevel global;
+
+// solhint-disable-next-line func-name-mixedcase
+function DAMAGE_SMALL() pure returns (DamageLevel) {
+    return DamageLevel.wrap(1);
+}
+
+// solhint-disable-next-line func-name-mixedcase
+function DAMAGE_MEDIUM() pure returns (DamageLevel) {
+    return DamageLevel.wrap(2);
+}
+
+// solhint-disable-next-line func-name-mixedcase
+function DAMAGE_LARGE() pure returns (DamageLevel) {
+    return DamageLevel.wrap(3);
+}
+
+library DamageLevelLib {
+
+    error ErrorDamageLeveLibInvalidDamageLevel(uint8 damageLevel);
+
+    function zero() internal pure returns (DamageLevel) {
+        return DamageLevel.wrap(0);
+    }
+
+    function toDamageLevel(uint8 damage) internal pure returns (DamageLevel) {
+        if (damage == 1) {
+            return DAMAGE_SMALL();
+        } else if (damage == 2) {
+            return DAMAGE_MEDIUM();
+        } else if (damage == 3) {
+            return DAMAGE_LARGE();
+        } else {
+            revert ErrorDamageLeveLibInvalidDamageLevel(damage);
+        }
+    }
+
+    function toInt(DamageLevel damageLevel) internal pure returns (uint8) {
+        return uint8(DamageLevel.unwrap(damageLevel));
+    }
+
+    function eq(DamageLevel a, DamageLevel b) internal pure returns (bool) {
+        return DamageLevel.unwrap(a) == DamageLevel.unwrap(b);
+    }
+
+    function eqz(DamageLevel a) internal pure returns (bool) {
+        return DamageLevel.unwrap(a) == 0;
+    }
+}