@etherisc/gif-next 0.0.2-c6d46bb-892 → 0.0.2-c75d1c9-837

package/contracts/distribution/IDistributionComponent.sol

@@ -1,71 +1,43 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {Fee} from "../type/Fee.sol";
-import {IComponent} from "../shared/IComponent.sol";
-import {ISetup} from "../instance/module/ISetup.sol";
-import {ReferralId, ReferralStatus} from "../type/Referral.sol";
+import {Amount} from "../type/Amount.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
 import {NftId} from "../type/NftId.sol";
-import {DistributorType} from "../type/DistributorType.sol";
+import {ReferralId, ReferralStatus} from "../type/Referral.sol";
 import {UFixed} from "../type/UFixed.sol";
-import {Timestamp} from "../type/Timestamp.sol";
-
-interface IDistributionComponent is IComponent {
 
-    event LogDistributorUpdated(address to, address caller);
-
-    function getSetupInfo() external view returns (ISetup.DistributionSetupInfo memory setupInfo);
-
-    function setFees(
-        Fee memory minDistributionOwnerFee,
-        Fee memory distributionFee
-    ) external;
+interface IDistributionComponent is IInstanceLinkedComponent {
 
-    function createDistributorType(
-        string memory name,
-        UFixed minDiscountPercentage,
-        UFixed maxDiscountPercentage,
-        UFixed commissionPercentage,
-        uint32 maxReferralCount,
-        uint32 maxReferralLifetime,
-        bool allowSelfReferrals,
-        bool allowRenewals,
-        bytes memory data
-    ) external returns (DistributorType distributorType);
+    event LogDistributorUpdated(address to, address operator);
 
-    function createDistributor(
-        address distributor,
-        DistributorType distributorType,
-        bytes memory data
-    ) external returns(NftId distributorNftId);
+    function getDiscountPercentage(
+        string memory referralCode
+    ) external view returns (UFixed discountPercentage, ReferralStatus status);
 
-    function updateDistributorType(
-        NftId distributorNftId,
-        DistributorType distributorType,
-        bytes memory data
-    ) external;
+    function getReferralId(
+        string memory referralCode
+    ) external returns (ReferralId referralId);
 
     function calculateRenewalFeeAmount(
         ReferralId referralId,
         uint256 netPremiumAmount
     ) external view returns (uint256 feeAmount);
 
-    /// @dev callback from product service when a policy is renews for a specific referralId
+    /// @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;
 
-    function getDiscountPercentage(
-        string memory referralCode
-    ) external view returns (UFixed discountPercentage, ReferralStatus status);
-
-    function getDistributionFee() external view returns (Fee memory distibutionFee);
-
-    function getReferralId(
-        string memory referralCode
-    ) external returns (ReferralId referralId);
-
-    /// @dev returns true iff the component needs to be called when selling/renewing policis
+    /// @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

@@ -1,46 +1,51 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
 import {NftId} from "../type/NftId.sol";
-import {Fee} from "../type/Fee.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 ErrorDistributionServiceCallerNotRegistered(address caller);
-    error ErrorIDistributionServiceParentNftIdNotInstance(NftId nftId, NftId parentNftId);
-    error ErrorIDistributionServiceCallerNotDistributor(address caller);
-    error ErrorIDistributionServiceInvalidReferralId(ReferralId referralId);
-    error ErrorIDistributionServiceMaxReferralsExceeded(uint256 maxReferrals);
-    error ErrorIDistributionServiceDiscountTooLow(uint256 minDiscountPercentage, uint256 discountPercentage);
-    error ErrorIDistributionServiceDiscountTooHigh(uint256 maxDiscountPercentage, uint256 discountPercentage);
-    error ErrorIDistributionServiceExpiryTooLong(uint256 maxReferralLifetime, uint256 expiryAt);
-    error ErrorIDistributionServiceInvalidReferral(string code);
-    error ErrorIDistributionServiceExpirationInvalid(Timestamp expiryAt);
-    error ErrorIDistributionServiceCommissionTooHigh(uint256 commissionPercentage, uint256 maxCommissionPercentage);
-    error ErrorIDistributionServiceMinFeeTooHigh(uint256 minFee, uint256 limit);
-    error ErrorIDistributionServiceMaxDiscountTooHigh(uint256 maxDiscountPercentage, uint256 limit);
-    error ErrorIDistributionServiceReferralInvalid(NftId distributionNftId, ReferralId referralId);
-    error ErrorDistributionServiceInvalidFeeTransferred(Amount transferredDistributionFeeAmount, Amount expectedDistributionFeeAmount);
+    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 ErrorDistributionServiceDistributorTypeDistributionMismatch(DistributorType distributorType, NftId distributorTypeDistributionNftId, NftId distributionNftId);
+    error ErrorDistributionServiceDistributorDistributionMismatch(NftId distributorNftId, NftId distributorDistributionNftId, NftId distributionNftId);
 
-    function setFees(
-        Fee memory minDistributionOwnerFee,
-        Fee memory distributionFee
-    ) external;
+    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);
+    error ErrorDistributionServiceReferralDistributionMismatch(ReferralId referralId, NftId referralDistributionNft, NftId distributionNftId);
+
+    event LogDistributionServiceCommissionWithdrawn(NftId distributorNftId, address recipient, address tokenAddress, Amount amount);
+
     function createDistributorType(
         string memory name,
         UFixed minDiscountPercentage,
         UFixed maxDiscountPercentage,
         UFixed commissionPercentage,
         uint32 maxReferralCount,
-        uint32 maxReferralLifetime,
+        Seconds maxReferralLifetime,
         bool allowSelfReferrals,
         bool allowRenewals,
         bytes memory data
@@ -54,12 +59,11 @@ interface IDistributionService is IService {
         bytes memory data
     ) external returns (NftId distributorNftId);
 
-    // TODO re-enable and reorganize (service contract too large)
-    // function updateDistributorType(
-    //     NftId distributorNftId,
-    //     DistributorType distributorType,
-    //     bytes memory data
-    // ) external;
+    function changeDistributorType(
+        NftId distributorNftId,
+        DistributorType newDistributorType,
+        bytes memory data
+    ) external;
 
     function createReferral(
         NftId distributorNftId,
@@ -72,16 +76,28 @@ interface IDistributionService is IService {
         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.Premium memory premium,
-        Amount transferredDistributionFeeAmount
+        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;
+    }
+}

package/contracts/examples/fire/FirePool.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Amount, AmountLib} from "../../type/Amount.sol";
+import {BasicPool} from "../../pool/BasicPool.sol";
+import {Fee} from "../../type/Fee.sol";
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+import {IComponents} from "../../instance/module/IComponents.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Seconds} from "../../type/Timestamp.sol";
+import {UFixed, UFixedLib} from "../../type/UFixed.sol";
+
+contract FirePool is
+    BasicPool
+{   
+    constructor(
+        address registry,
+        NftId fireProductNftId,
+        string memory componentName,
+        IAuthorization authorization
+    ) 
+    {
+        address initialOwner = msg.sender;
+        _intialize(
+            registry,
+            fireProductNftId,
+            componentName,
+            IComponents.PoolInfo({
+                maxBalanceAmount: AmountLib.max(),
+                isInterceptingBundleTransfers: false,
+                isProcessingConfirmedClaims: false,
+                isExternallyManaged: false,
+                isVerifyingApplications: false,
+                collateralizationLevel: UFixedLib.one(),
+                retentionLevel: UFixedLib.one()
+            }),
+            authorization,
+            initialOwner);
+    }
+
+    function _intialize(
+        address registry,
+        NftId fireProductNftId,
+        string memory componentName,
+        IComponents.PoolInfo memory poolInfo,
+        IAuthorization authorization,
+        address initialOwner
+    )
+        internal
+        initializer
+    {
+        _initializeBasicPool(
+            registry,
+            fireProductNftId,
+            componentName,
+            poolInfo,
+            authorization,
+            initialOwner);
+    }
+
+    function createBundle(
+        Fee memory fee,
+        Amount initialAmount,
+        Seconds lifetime
+    )
+        external
+        virtual 
+        restricted()
+        returns(NftId bundleNftId, Amount netStakedAmount)
+    {
+        address owner = msg.sender;
+        bundleNftId = _createBundle(
+            owner,
+            fee,
+            lifetime,
+            "" // filter
+        );
+        netStakedAmount = _stake(bundleNftId, initialAmount);
+    }
+
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external restricted() onlyOwner() { _approveTokenHandler(token, amount); }
+    function setLocked(bool locked) external onlyOwner() { _setLocked(locked); }
+    function setWallet(address newWallet) external restricted() onlyOwner() { _setWallet(newWallet); }
+}

package/contracts/examples/fire/FirePoolAuthorization.sol

@@ -0,0 +1,35 @@
+
+
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {BasicPoolAuthorization} from "../../pool/BasicPoolAuthorization.sol";
+import {FirePool} from "./FirePool.sol";
+import {IAccess} from "../../../contracts/authorization/IAccess.sol";
+import {PUBLIC_ROLE} from "../../../contracts/type/RoleId.sol";
+
+contract FirePoolAuthorization
+    is BasicPoolAuthorization
+{
+
+    constructor(string memory poolName)
+        BasicPoolAuthorization(poolName)
+    {}
+
+
+    function _setupTargetAuthorizations()
+        internal
+        virtual override
+    {
+        super._setupTargetAuthorizations();
+        IAccess.FunctionInfo[] storage functions;
+
+        // authorize public role (open access to any account, only allows to lock target)
+        functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+        // TODO: FirePool.createBundle must require a custom role (e.g. INVESTOR) instead of PUBLIC_ROLE
+        _authorize(functions, FirePool.approveTokenHandler.selector, "approveTokenHandler");
+        _authorize(functions, FirePool.createBundle.selector, "createBundle");
+    }
+
+}
+