@etherisc/gif-next 0.0.2-8bdd2eb-413 → 0.0.2-8d6e553-386

package/contracts/authorization/ServiceAuthorization.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "../authorization/IAccess.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {IServiceAuthorization} from "./IServiceAuthorization.sol";
+import {SelectorLib} from "../type/Selector.sol";
+import {StrLib} from "../type/String.sol";
+import {TimestampLib} from "../type/Timestamp.sol";
+import {VersionPart, VersionPartLib} from "../type/Version.sol";
+
+/// @dev Base contract for release specific service authorization contracts.
+contract ServiceAuthorization
+     is IServiceAuthorization
+{
+     uint256 public constant GIF_VERSION_3 = 3;
+
+     string private _commitHash;
+
+     ObjectType[] internal _serviceDomains;
+     mapping(ObjectType domain => address service) internal _serviceAddress;
+     mapping(ObjectType domain => ObjectType[] authorizedDomains) internal _authorizedDomains;
+     mapping(ObjectType domain => mapping(ObjectType authorizedDomain => IAccess.FunctionInfo[] functions)) internal _authorizedFunctions;
+
+     constructor(string memory commitHash) {
+          _commitHash = commitHash;
+          _setupDomains();
+          _setupDomainAuthorizations();
+     }
+
+     function getCommitHash() external view returns(string memory commitHash) {
+          return _commitHash;
+     }
+
+     function getRelease() external view returns(VersionPart release) {
+          return VersionPartLib.toVersionPart(GIF_VERSION_3);
+     }
+
+     function getServiceDomains() external view returns(ObjectType[] memory serviceDomains) {
+          return _serviceDomains;
+     }
+
+     function getServiceDomain(uint idx) external view returns(ObjectType serviceDomain) {
+          return _serviceDomains[idx];
+     }
+
+     function getServiceAddress(ObjectType serviceDomain) external view returns(address service) {
+          return _serviceAddress[serviceDomain];
+     }
+
+     function getAuthorizedDomains(ObjectType serviceDomain) external view returns(ObjectType[] memory authorizatedDomains) {
+          return _authorizedDomains[serviceDomain];
+     }
+
+     function getAuthorizedFunctions(ObjectType serviceDomain, ObjectType authorizedDomain) external view returns(IAccess.FunctionInfo[] memory authorizatedFunctions) {
+          return _authorizedFunctions[serviceDomain][authorizedDomain];
+     }
+
+     /// @dev Overwrite this function for a specific realease.
+     function _setupDomains() internal virtual {}
+
+     /// @dev Overwrite this function for a specific realease.
+     function _setupDomainAuthorizations() internal virtual {}
+
+     /// @dev Use this method to to add an authorized domain.
+     /// The services will need to be registered in the order they are added using this function.
+     function _authorizeDomain(ObjectType serviceDomain, address serviceAddress) internal {
+          _serviceDomains.push(serviceDomain);
+          _serviceAddress[serviceDomain] = serviceAddress;
+     }
+
+     /// @dev Use this method to authorize the specified domain to access the service domain.
+     function _authorizeForService(ObjectType serviceDomain, ObjectType authorizedDomain)
+          internal
+          returns (IAccess.FunctionInfo[] storage authorizatedFunctions)
+     {
+          _authorizedDomains[serviceDomain].push(authorizedDomain);
+          return _authorizedFunctions[serviceDomain][authorizedDomain];
+     }
+
+     /// @dev Use this method to authorize a specific function authorization
+     function _authorize(IAccess.FunctionInfo[] storage functions, bytes4 selector, string memory name) internal {
+          functions.push(
+               IAccess.FunctionInfo({
+                    selector: SelectorLib.toSelector(selector),
+                    name: StrLib.toStr(name),
+                    createdAt: TimestampLib.blockTimestamp()}));
+     }
+}
+

package/contracts/distribution/BasicDistribution.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {COMPONENT, DISTRIBUTION} from "../type/ObjectType.sol";
+import {Distribution} from "./Distribution.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
+import {IDistributionService} from "./IDistributionService.sol";
+import {IProductService} from "../product/IProductService.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {ReferralId, ReferralStatus, ReferralLib} from "../type/Referral.sol";
+import {Fee, FeeLib} from "../type/Fee.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
+import {IDistribution} from "../instance/module/IDistribution.sol";
+import {IDistributionComponent} from "./IDistributionComponent.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
+
+
+contract BasicDistribution is
+    Distribution
+{
+
+    function setFees(
+        Fee memory distributionFee,
+        Fee memory minDistributionOwnerFee
+    )
+        external
+        virtual
+        onlyOwner()
+        restricted()
+    {
+        _setFees(
+            distributionFee, 
+            minDistributionOwnerFee);
+    }
+
+
+    function createDistributorType(
+        string memory name,
+        UFixed minDiscountPercentage,
+        UFixed maxDiscountPercentage,
+        UFixed commissionPercentage,
+        uint32 maxReferralCount,
+        uint32 maxReferralLifetime,
+        bool allowSelfReferrals,
+        bool allowRenewals,
+        bytes memory data
+    )
+        external
+        virtual
+        onlyOwner()
+        restricted()
+        returns (DistributorType distributorType)
+    {
+        return _createDistributorType(
+            name,
+            minDiscountPercentage,
+            maxDiscountPercentage,
+            commissionPercentage,
+            maxReferralCount,
+            maxReferralLifetime,
+            allowSelfReferrals,
+            allowRenewals,
+            data);
+    }
+
+    function createDistributor(
+        address distributor,
+        DistributorType distributorType,
+        bytes memory data
+    )
+        external
+        virtual
+        onlyOwner()
+        restricted()
+        returns(NftId distributorNftId)
+    {
+        return _createDistributor(distributor, distributorType, data);
+    }
+
+    function updateDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    )
+        external
+        virtual
+        onlyOwner()
+        restricted()
+    {
+        _updateDistributorType(distributorNftId, distributorType, data);
+    }
+
+    /**
+     * @dev lets distributors create referral codes.
+     * referral codes need to be unique
+     */
+    function createReferral(
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    )
+        external
+        virtual
+        onlyDistributor()
+        restricted()
+        returns (ReferralId referralId)
+    {
+        NftId distributorNftId = getDistributorNftId(msg.sender);
+        return _createReferral(
+            distributorNftId,
+            code,
+            discountPercentage,
+            maxReferrals,
+            expiryAt,
+            data); // data
+    }
+
+    function _initializeBasicDistribution(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization, 
+        address initialOwner,
+        string memory name,
+        address token
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _initializeDistribution(
+            registry, 
+            instanceNftId, 
+            authorization,
+            initialOwner, 
+            name, 
+            token, 
+            "", // registry data
+            ""); // component specifc data
+    }
+}

package/contracts/distribution/BasicDistributionAuthorization.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Authorization} from "../authorization/Authorization.sol";
+import {BasicDistribution} from "./BasicDistribution.sol"; 
+import {DISTRIBUTION} from "../type/ObjectType.sol";
+import {IAccess} from "../authorization/IAccess.sol";
+import {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+
+contract BasicDistributionAuthorization
+     is Authorization
+{
+
+     constructor(string memory distributionlName)
+          Authorization(distributionlName)
+     {}
+
+     function _setupTargets()
+          internal
+          virtual override
+     {
+          _addComponentTargetWithRole(DISTRIBUTION()); // basic target
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), PUBLIC_ROLE());
+          _authorize(functions, BasicDistribution.setFees.selector, "setFees");
+          _authorize(functions, BasicDistribution.createDistributorType.selector, "createDistributorType");
+          _authorize(functions, BasicDistribution.createDistributor.selector, "createDistributor");
+          _authorize(functions, BasicDistribution.updateDistributorType.selector, "updateDistributorType");
+          _authorize(functions, BasicDistribution.createReferral.selector, "createReferral");
+     }
+}
+

package/contracts/distribution/Distribution.sol

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {Amount, AmountLib} from "../type/Amount.sol";
 import {COMPONENT, DISTRIBUTION} from "../type/ObjectType.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IDistributionService} from "./IDistributionService.sol";
 import {IProductService} from "../product/IProductService.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
@@ -33,22 +35,134 @@ abstract contract Distribution is
         mapping(address distributor => NftId distributorNftId) _distributorNftId;
     }
 
-    error ErrorDistributionAlreadyDistributor(address distributor, NftId distributorNftId);
+    modifier onlyDistributor() {
+        if (!isDistributor(msg.sender)) {
+            revert ErrorDistributionNotDistributor(msg.sender);
+        }
+        _;
+    }
+
+
+    function register()
+        external
+        virtual
+        onlyOwner()
+    {
+        _getDistributionStorage()._componentService.registerDistribution();
+        _approveTokenHandler(type(uint256).max);
+    }
+
+
+    function isDistributor(address candidate)
+        public
+        view
+        returns (bool)
+    {
+        DistributionStorage storage $ = _getDistributionStorage();
+        return $._distributorNftId[candidate].gtz();
+    }
+
+
+    function getDistributorNftId(address distributor)
+        public
+        view
+        returns (NftId distributorNftId)
+    {
+        DistributionStorage storage $ = _getDistributionStorage();
+        return $._distributorNftId[distributor];
+    }
+
+
+    function getDiscountPercentage(string memory referralCode)
+        external
+        view
+        returns (
+            UFixed discountPercentage, 
+            ReferralStatus status
+        )
+    {
+        ReferralId referralId = getReferralId(referralCode);
+        return _getInstanceReader().getDiscountPercentage(referralId);
+    }
+
 
-    function initializeDistribution(
+    function getReferralId(
+        string memory referralCode
+    )
+        public
+        view 
+        returns (ReferralId referralId)
+    {
+        return ReferralLib.toReferralId(
+            getNftId(), 
+            referralCode);      
+    }
+
+
+    function calculateRenewalFeeAmount(
+        ReferralId referralId,
+        uint256 netPremiumAmount
+    )
+        external
+        view
+        virtual override
+        returns (uint256 feeAmount)
+    {
+        // default is no fees
+        return 0 * netPremiumAmount;
+    }
+
+
+    function processRenewal(
+        ReferralId referralId,
+        uint256 feeAmount
+    )
+        external
+        virtual
+        restricted()
+    {
+        // default is no action
+    }
+
+    /// @dev Returns true iff the component needs to be called when selling/renewing policis
+    function isVerifying() external pure returns (bool verifying) {
+        return true;
+    }
+
+    function withdrawFees(Amount amount)
+        external
+        virtual
+        onlyOwner()
+        returns (Amount withdrawnAmount)
+    {
+        return _withdrawFees(amount);
+    }
+
+    function _initializeDistribution(
         address registry,
         NftId instanceNftId,
+        IAuthorization authorization, 
         address initialOwner,
         string memory name,
         address token,
         bytes memory registryData, // writeonly data that will saved in the object info record of the registry
         bytes memory componentData // component specifidc data 
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeInstanceLinkedComponent(registry, instanceNftId, name, token, DISTRIBUTION(), true, initialOwner, registryData, componentData);
+        _initializeInstanceLinkedComponent(
+            registry, 
+            instanceNftId, 
+            name, 
+            token, 
+            DISTRIBUTION(), 
+            authorization,
+            true, 
+            initialOwner, 
+            registryData, 
+            componentData);
 
         DistributionStorage storage $ = _getDistributionStorage();
         $._distributionService = IDistributionService(_getServiceAddress(DISTRIBUTION())); 
@@ -57,30 +171,21 @@ abstract contract Distribution is
         registerInterface(type(IDistributionComponent).interfaceId);
     }
 
-    function register()
-        external
-        virtual
-        onlyOwner()
-    {
-        _getDistributionStorage()._componentService.registerDistribution();
-    }
-
-    function setFees(
+    /// @dev Sets the distribution fees to the provided values.
+    function _setFees(
         Fee memory distributionFee,
         Fee memory minDistributionOwnerFee
     )
-        external
-        override
-        onlyOwner()
-        restricted()
+        internal
+        virtual
     {
         _getDistributionStorage()._componentService.setDistributionFees(
             distributionFee, 
             minDistributionOwnerFee);
     }
 
-
-    function createDistributorType(
+    /// @dev Creates a new distributor type using the provided parameters.
+    function _createDistributorType(
         string memory name,
         UFixed minDiscountPercentage,
         UFixed maxDiscountPercentage,
@@ -91,7 +196,8 @@ abstract contract Distribution is
         bool allowRenewals,
         bytes memory data
     )
-        public
+        internal
+        virtual
         returns (DistributorType distributorType)
     {
         DistributionStorage storage $ = _getDistributionStorage();
@@ -107,12 +213,14 @@ abstract contract Distribution is
             data);
     }
 
-    function createDistributor(
+    /// @dev Turns the provided account into a new distributor of the specified type.
+    function _createDistributor(
         address distributor,
         DistributorType distributorType,
         bytes memory data
     )
-        public
+        internal
+        virtual
         returns(NftId distributorNftId)
     {
         DistributionStorage storage $ = _getDistributionStorage();
@@ -128,14 +236,14 @@ abstract contract Distribution is
         $._distributorNftId[distributor] = distributorNftId;
     }
 
-    function updateDistributorType(
+    /// @dev Uptates the distributor type for the specified distributor.
+    function _updateDistributorType(
         NftId distributorNftId,
         DistributorType distributorType,
         bytes memory data
     )
-        public
-        // TODO figure out what we need for authz
-        // and add it
+        internal
+        virtual
     {
         DistributionStorage storage $ = _getDistributionStorage();
         // TODO re-enable once implemented
@@ -145,10 +253,7 @@ abstract contract Distribution is
         //     data);
     }
 
-    /**
-     * @dev lets distributors create referral codes.
-     * referral codes need to be unique
-     */
+    /// @dev Create a new referral code for the provided distributor.
     function _createReferral(
         NftId distributorNftId,
         string memory code,
@@ -158,6 +263,7 @@ abstract contract Distribution is
         bytes memory data
     )
         internal
+        virtual
         returns (ReferralId referralId)
     {
         DistributionStorage storage $ = _getDistributionStorage();
@@ -170,72 +276,12 @@ abstract contract Distribution is
             data);
     }
 
-    function isDistributor(address candidate)
-        public
-        view
-        returns (bool)
-    {
-        DistributionStorage storage $ = _getDistributionStorage();
-        return $._distributorNftId[candidate].gtz();
-    }
-
-    function getDistributorNftId(address distributor)
-        public
-        view
-        returns (NftId distributorNftId)
-    {
-        DistributionStorage storage $ = _getDistributionStorage();
-        return $._distributorNftId[distributor];
-    }
-
-    function getDiscountPercentage(string memory referralCode)
-        external
-        view
-        returns (
-            UFixed discountPercentage, 
-            ReferralStatus status
-        )
-    {
-        ReferralId referralId = getReferralId(referralCode);
-        return _getInstanceReader().getDiscountPercentage(referralId);
-    }
-
-
-    function getReferralId(
-        string memory referralCode
-    )
-        public
-        view 
-        returns (ReferralId referralId)
-    {
-        return ReferralLib.toReferralId(
-            getNftId(), 
-            referralCode);      
-    }
-
-    function calculateRenewalFeeAmount(
-        ReferralId referralId,
-        uint256 netPremiumAmount
-    )
-        external
-        view
-        virtual override
-        returns (uint256 feeAmount)
-    {
-        // default is no fees
-        return 0 * netPremiumAmount;
-    }
-
-    function processRenewal(
-        ReferralId referralId,
-        uint256 feeAmount
-    )
-        external
-        onlyOwner
-        restricted()
-        virtual override
+    function _withdrawFees(Amount amount)
+        internal
+        virtual
+        returns (Amount withdrawnAmount)
     {
-        // default is no action
+        return _getDistributionStorage()._componentService.withdrawFees(amount);
     }
 
 
@@ -246,12 +292,6 @@ abstract contract Distribution is
         $._distributorNftId[from] = NftIdLib.zero();
         $._distributorNftId[to] = NftIdLib.toNftId(tokenId);
     }
-    
-
-    /// @dev returns true iff the component needs to be called when selling/renewing policis
-    function isVerifying() external pure returns (bool verifying) {
-        return true;
-    }
 
     function _getDistributionStorage() private pure returns (DistributionStorage storage $) {
         assembly {

package/contracts/distribution/DistributionService.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.20;
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IInstance} from "../instance/IInstance.sol";
-import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
@@ -14,29 +13,14 @@ import {IPolicy} from "../instance/module/IPolicy.sol";
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
-import {PRODUCT_SERVICE_ROLE, DISTRIBUTION_OWNER_ROLE} from "../type/RoleId.sol";
 import {KEEP_STATE} from "../type/StateId.sol";
 import {ObjectType, COMPONENT, DISTRIBUTION, INSTANCE, DISTRIBUTION, DISTRIBUTOR, REGISTRY} from "../type/ObjectType.sol";
-import {Version, VersionLib} from "../type/Version.sol";
-import {RoleId} from "../type/RoleId.sol";
-
-import {IVersionable} from "../shared/IVersionable.sol";
-import {Versionable} from "../shared/Versionable.sol";
-
-import {IService} from "../shared/IService.sol";
-import {Service} from "../shared/Service.sol";
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
-import {InstanceService} from "../instance/InstanceService.sol";
-import {IComponent} from "../shared/IComponent.sol";
-import {IDistributionComponent} from "../distribution/IDistributionComponent.sol";
 import {IDistributionService} from "./IDistributionService.sol";
-import {IPricingService} from "../product/IPricingService.sol";
-
 import {UFixed, UFixedLib} from "../type/UFixed.sol";
 import {DistributorType, DistributorTypeLib} from "../type/DistributorType.sol";
-import {ReferralId, ReferralStatus, ReferralLib} from "../type/Referral.sol";
-import {Timestamp, TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
-import {Key32} from "../type/Key32.sol";
+import {ReferralId, ReferralLib} from "../type/Referral.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
 import {IDistribution} from "../instance/module/IDistribution.sol";
 import {InstanceStore} from "../instance/InstanceStore.sol";
 
@@ -77,10 +61,6 @@ contract DistributionService is
         registerInterface(type(IDistributionService).interfaceId);
     }
 
-    function getDomain() public pure override returns(ObjectType) {
-        return DISTRIBUTION();
-    }
-
 
     function createDistributorType(
         string memory name,
@@ -102,10 +82,17 @@ contract DistributionService is
         {
             NftId productNftId = _getProductNftId(instanceReader, distributionNftId);
             IComponents.ProductInfo memory productInfo = instance.getInstanceReader().getProductInfo(productNftId);
-            UFixed variableFeesPartsTotal = productInfo.minDistributionOwnerFee.fractionalFee.add(commissionPercentage);
-            UFixed maxDiscountPercentageLimit = productInfo.distributionFee.fractionalFee.sub(variableFeesPartsTotal);
+
+            UFixed variableDistributionFees = productInfo.distributionFee.fractionalFee;
+            UFixed variableFeesPartsTotal = productInfo.minDistributionOwnerFee.fractionalFee + commissionPercentage;
+
+            if (variableFeesPartsTotal > variableDistributionFees) {
+                revert ErrorDistributionServiceVariableFeesTooHight(variableDistributionFees.toInt1000(), variableFeesPartsTotal.toInt1000());
+            }
+            UFixed maxDiscountPercentageLimit = variableDistributionFees - variableFeesPartsTotal;
+
             if (maxDiscountPercentage.gt(maxDiscountPercentageLimit)) {
-                revert ErrorIDistributionServiceMaxDiscountTooHigh(maxDiscountPercentage.toInt(), maxDiscountPercentageLimit.toInt());
+                revert ErrorDistributionServiceMaxDiscountTooHigh(maxDiscountPercentage.toInt1000(), maxDiscountPercentageLimit.toInt1000());
             }
         }
 
@@ -295,4 +282,7 @@ contract DistributionService is
         return IInstance(instanceAddress);
     }
 
+    function _getDomain() internal pure override returns(ObjectType) {
+        return DISTRIBUTION();
+    }
 }