@etherisc/gif-next 0.0.2-e818783-565 → 0.0.2-e8b06c8-540

package/contracts/authorization/ModuleAuthorization.sol

@@ -0,0 +1,203 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Authorization} from "./Authorization.sol";
+import {IAccess} from "./IAccess.sol";
+import {IModuleAuthorization} from "./IModuleAuthorization.sol";
+import {ObjectType, ObjectTypeLib} from "../type/ObjectType.sol";
+import {RoleId, RoleIdLib, ADMIN_ROLE} from "../type/RoleId.sol";
+import {SelectorLib} from "../type/Selector.sol";
+import {Str, StrLib} from "../type/String.sol";
+import {TimestampLib} from "../type/Timestamp.sol";
+import {VersionPart} from "../type/Version.sol";
+
+contract ModuleAuthorization is
+     Authorization,
+     IModuleAuthorization
+{
+
+     // TODO cleanup
+     // Str[] internal _targets;
+     ObjectType[] internal _serviceDomains;
+
+     mapping(ObjectType domain => Str target) internal _serviceTarget;
+     // mapping(Str target => RoleId roleid) internal _targetRole;
+     // mapping(Str target => bool exists) internal _targetExists;
+
+     // RoleId[] internal _roles;
+     // mapping(RoleId role => RoleInfo info) internal _roleInfo;
+
+     // mapping(Str target => RoleId[] authorizedRoles) internal _authorizedRoles;
+     // mapping(Str target => mapping(RoleId authorizedRole => IAccess.FunctionInfo[] functions)) internal _authorizedFunctions;
+
+     constructor(string memory moduleName)
+          Authorization(moduleName)
+     { }
+
+     // function getRoles() external view returns(RoleId[] memory roles) {
+     //      return _roles;
+     // }
+
+     // function getRoleInfo(RoleId roleId) external view returns (RoleInfo memory info) {
+     //      return _roleInfo[roleId];
+     // }
+
+     // function roleExists(RoleId roleId) public view returns(bool exists) {
+     //      return _roleInfo[roleId].roleType != RoleType.Undefined;
+     // }
+
+     // function getTargets() external view returns(Str[] memory targets) {
+     //      return _targets;
+     // }
+
+     function getServiceDomains() external view returns(ObjectType[] memory serviceDomains) {
+          return _serviceDomains;
+     }
+
+     function getServiceTarget(ObjectType serviceDomain) external view returns(Str serviceTarget) {
+          return _serviceTarget[serviceDomain];
+     }
+
+     // function getTargetRole(Str target) external view returns(RoleId roleId) {
+     //      return _targetRole[target];
+     // }
+
+     // function getAuthorizedRoles(Str target) external view returns(RoleId[] memory roleIds) {
+     //      return _authorizedRoles[target];
+     // }
+
+     // function getAuthorizedFunctions(Str target, RoleId roleId) external view returns(IAccess.FunctionInfo[] memory authorizatedFunctions) {
+     //      return _authorizedFunctions[target][roleId];
+     // }
+
+     // /// @dev Overwrite this function for a specific realease.
+     // function _setupTargets() internal virtual {}
+
+     // /// @dev Overwrite this function for a specific realease.
+     // function _setupRoles() internal virtual {}
+
+     // /// @dev Overwrite this function for a specific realease.
+     // function _setupTargetAuthorizations() internal virtual {}
+
+     // /// @dev Use this method to to add an authorized role.
+     // function _addRole(RoleId roleId, RoleInfo memory info) internal {
+     //      _roles.push(roleId);
+     //      _roleInfo[roleId] = info;
+     // }
+
+     /// @dev Add a GIF role for the provided role id and name.
+     function _addGifRole(RoleId roleId, string memory name) internal returns (RoleInfo memory info) {
+          _addRole(
+               roleId,
+               _toRoleInfo(
+                    ADMIN_ROLE(),
+                    RoleType.Gif,
+                    type(uint32).max,
+                    name));
+     }
+
+     // /// @dev Add a contract role for the provided role id and name.
+     // function _addContractRole(RoleId roleId, string memory name) internal {
+     //      _addRole(
+     //           roleId,
+     //           _toRoleInfo(
+     //                ADMIN_ROLE(),
+     //                RoleType.Contract,
+     //                1,
+     //                name));
+     // }
+
+     /// @dev Add the service target role for the specified service domain
+     function _addServiceTargetWithRole(ObjectType serviceDomain) internal {
+          // add service domain
+          _serviceDomains.push(serviceDomain);
+
+          // get versioned target name
+          string memory serviceTargetName = ObjectTypeLib.toVersionedName(
+                    ObjectTypeLib.toName(serviceDomain), 
+                    "Service", 
+                    getRelease().toInt());
+
+          _serviceTarget[serviceDomain] = StrLib.toStr(serviceTargetName);
+
+          RoleId serviceRoleId = getServiceRole(serviceDomain);
+          string memory serviceRoleName = ObjectTypeLib.toVersionedName(
+                    ObjectTypeLib.toName(serviceDomain), 
+                    "ServiceRole", 
+                    getRelease().toInt());
+
+          _addTargetWithRole(
+               serviceTargetName,
+               serviceRoleId,
+               serviceRoleName);
+     }
+
+     // /// @dev Use this method to to add an authorized target together with its target role.
+     // function _addTargetWithRole(
+     //      string memory targetName, 
+     //      RoleId roleId, 
+     //      string memory roleName
+     // )
+     //      internal
+     // {
+     //      // add target
+     //      Str target = StrLib.toStr(targetName);
+     //      _targets.push(target);
+
+     //      _targetExists[target] = true;
+
+     //      // link role to target if defined
+     //      if (roleId != RoleIdLib.zero()) {
+     //           // add role if new
+     //           if (!roleExists(roleId)) {
+     //                _addContractRole(roleId, roleName);
+     //           }
+
+     //           // link target to role
+     //           _targetRole[target] = roleId;
+     //      }
+     // }
+
+     // /// @dev creates a role info object from the provided parameters
+     // function _toRoleInfo(RoleId adminRoleId, RoleType roleType, uint32 maxMemberCount, string memory name) internal view returns (RoleInfo memory info) {
+     //      return RoleInfo({
+     //           name: StrLib.toStr(name),
+     //           adminRoleId: adminRoleId,
+     //           roleType: roleType,
+     //           maxMemberCount: maxMemberCount,
+     //           createdAt: TimestampLib.blockTimestamp()});
+     // }
+
+     // /// @dev Use this method to to add an authorized target.
+     // function _addTarget(string memory name) internal {
+     //      _addTargetWithRole(name, RoleIdLib.zero(), "");
+     // }
+
+     // /// @dev Use this method to authorize the specified role to access the target.
+     // function _authorizeForTarget(string memory target, RoleId authorizedRoleId)
+     //      internal
+     //      returns (IAccess.FunctionInfo[] storage authorizatedFunctions)
+     // {
+     //      Str targetStr = StrLib.toStr(target);
+     //      _authorizedRoles[targetStr].push(authorizedRoleId);
+     //      return _authorizedFunctions[targetStr][authorizedRoleId];
+     // }
+
+     // /// @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()}));
+     // }
+
+     /// @dev role id for targets registry, staking and instance
+     function _getTargetRoleId(ObjectType targetDomain) 
+          internal
+          returns (RoleId targetRoleId)
+     {
+          return RoleIdLib.roleForType(targetDomain);
+     }
+}
+

package/contracts/authorization/ServiceAuthorization.sol

@@ -0,0 +1,86 @@
+// 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 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");
+     }
+}
+