@etherisc/gif-next 0.0.2-bca36d7-613 → 0.0.2-be8b468-276

package/contracts/components/BaseComponent.sol

@@ -11,13 +11,15 @@ import {IInstance} from "../instance/IInstance.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {IComponentOwnerService} from "../instance/service/IComponentOwnerService.sol";
 import {IBaseComponent} from "./IBaseComponent.sol";
-import {NftId} from "../types/NftId.sol";
+import {NftId, zeroNftId, NftIdLib} from "../types/NftId.sol";
 import {ObjectType} from "../types/ObjectType.sol";
 
 abstract contract BaseComponent is
     Registerable,
     IBaseComponent
 {
+    using NftIdLib for NftId;
+
     IComponentOwnerService internal _componentOwnerService;
 
     address internal _deployer;
@@ -29,7 +31,6 @@ abstract contract BaseComponent is
     constructor(
         address registry,
         NftId instanceNftId,
-        NftId productNftId,
         address token,
         ObjectType componentType,
         bool isInterceptor,
@@ -49,7 +50,6 @@ abstract contract BaseComponent is
         _componentOwnerService = _instance.getComponentOwnerService();
         _wallet = address(this);
         _token = IERC20Metadata(token);
-        _productNftId = productNftId;
 
         _registerInterface(type(IBaseComponent).interfaceId);
     }
@@ -80,6 +80,11 @@ abstract contract BaseComponent is
         return _instance;
     }
 
+    function setProductNftId(NftId productNftId) public override onlyOwner {
+        require(_productNftId.eq(zeroNftId()), "product nft id already set");
+        _productNftId = productNftId;
+    }
+
     function getProductNftId() public view override returns (NftId productNftId) {
         return _productNftId;
     }

package/contracts/components/Distribution.sol

@@ -38,20 +38,19 @@ contract Distribution is
     constructor(
         address registry,
         NftId instanceNftId,
-        NftId productNftId,
         // TODO refactor into tokenNftId
         address token,
         bool verifying,
         Fee memory distributionFee,
         address initialOwner
     )
-        BaseComponent(registry, instanceNftId, productNftId, token, DISTRIBUTION(), true, initialOwner)
+        BaseComponent(registry, instanceNftId, token, DISTRIBUTION(), true, initialOwner)
     {
         _isVerifying = verifying;
         _initialDistributionFee = distributionFee;
 
+        _distributionService = _instance.getDistributionService();
         // TODO: reactivate when services are available again
-        // _distributionService = _instance.getDistributionService();
         // _productService = _instance.getProductService();
 
         _registerInterface(type(IDistributionComponent).interfaceId);
@@ -122,20 +121,21 @@ contract Distribution is
         return false;
     }
 
-    function getSetupInfo() public view returns (ISetup.DistributionSetupInfo memory setupInfo) {
-        if (getNftId().eq(zeroNftId())) {
-            return ISetup.DistributionSetupInfo(
-                _productNftId,
-                TokenHandler(address(0)),
-                _initialDistributionFee,
-                _isVerifying,
-                address(0)
-            );
-        } 
+    function getInitialSetupInfo() public view returns (ISetup.DistributionSetupInfo memory setupInfo) {
+        return ISetup.DistributionSetupInfo(
+            _productNftId,
+            TokenHandler(address(_token)),
+            _initialDistributionFee,
+            _isVerifying,
+            address(0) // TODO: use correct wallet
+        );
+    }
 
+    function getSetupInfo() public view returns (ISetup.DistributionSetupInfo memory setupInfo) {
         InstanceReader reader = _instance.getInstanceReader();
         return reader.getDistributionSetupInfo(getNftId());
     }
+    
 
     /// @dev returns true iff the component needs to be called when selling/renewing policis
     function isVerifying() external view returns (bool verifying) {

package/contracts/components/IBaseComponent.sol

@@ -19,6 +19,7 @@ interface IBaseComponent is IRegisterable {
 
     function getInstance() external view returns (IInstance instance);
 
+    function setProductNftId(NftId productNftId) external;
     function getProductNftId() external view returns (NftId productNftId);
 
 }

package/contracts/components/IDistributionComponent.sol

@@ -4,9 +4,12 @@ pragma solidity ^0.8.19;
 import {Fee} from "../types/Fee.sol";
 import {ReferralId} from "../types/Referral.sol";
 import {NftId} from "../types/NftId.sol";
+import {ISetup} from "../instance/module/ISetup.sol";
 
 interface IDistributionComponent {
 
+    function getInitialSetupInfo() external view returns (ISetup.DistributionSetupInfo memory setupInfo);
+
     function setFees(
         Fee memory distributionFee
     ) external;

package/contracts/components/Pool.sol

@@ -55,7 +55,6 @@ contract Pool is BaseComponent, IPoolComponent {
     constructor(
         address registry,
         NftId instanceNftId,
-        NftId productNftId,
         // TODO refactor into tokenNftId
         address token,
         bool isInterceptor,
@@ -66,7 +65,7 @@ contract Pool is BaseComponent, IPoolComponent {
         Fee memory performanceFee,
         address initialOwner
     )
-        BaseComponent(registry, instanceNftId, productNftId, token, POOL(), isInterceptor, initialOwner)
+        BaseComponent(registry, instanceNftId, token, POOL(), isInterceptor, initialOwner)
     {
         _isVerifying = verifying;
         // TODO add validation

package/contracts/components/Product.sol

@@ -49,7 +49,7 @@ contract Product is BaseComponent, IProductComponent {
         Fee memory productFee,
         Fee memory processingFee,
         address initialOwner
-    ) BaseComponent(registry, instanceNftid, zeroNftId(), token, PRODUCT(), isInterceptor, initialOwner) {
+    ) BaseComponent(registry, instanceNftid, token, PRODUCT(), isInterceptor, initialOwner) {
         // TODO add validation
         // TODO: reactivate when services are available again
         // _productService = _instance.getProductService();

package/contracts/instance/AccessManagedSimple.sol

@@ -24,14 +24,7 @@ abstract contract AccessManagedSimple is Context, IAccessManaged {
 
     bool private _consumingSchedule;
 
-    /**
-     * @dev Initializes the contract connected to an initial authority.
-     */
-    constructor(address initialAuthority) {
-        initialize(initialAuthority);
-    }
-
-    function initialize(address initialAuthority) public {
+    function initializeAccessManagedSimple(address initialAuthority) internal {
         require(!_initialized, "AccessManaged: already initialized");
         _setAuthority(initialAuthority);
         _initialized = true;

package/contracts/instance/IInstance.sol

@@ -11,17 +11,22 @@ import {IPoolService} from "./service/IPoolService.sol";
 import {IProductService} from "./service/IProductService.sol";
 import {ISetup} from "./module/ISetup.sol";
 import {NftId} from "../types/NftId.sol";
+import {StateId} from "../types/StateId.sol";
 
 interface IInstance is IERC165 {
 
     function getComponentOwnerService() external view returns (IComponentOwnerService);
     // TODO: renable these when we have the services
-    // function getDistributionService() external view returns (IDistributionService);
+    function getDistributionService() external view returns (IDistributionService);
     // function getProductService() external view returns (IProductService);
     // function getPoolService() external view returns (IPoolService);
 
     function createProductSetup(NftId productNftId, ISetup.ProductSetupInfo memory setup) external;
+
     function createDistributionSetup(NftId distributionNftId, ISetup.DistributionSetupInfo memory setup) external;
+    function updateDistributionSetup(NftId distributionNftId, ISetup.DistributionSetupInfo memory setup, StateId newState) external;
+    function updateDistributionSetupState(NftId distributionNftId, StateId newState) external;
+
     function createPoolSetup(NftId distributionNftId, ISetup.PoolSetupInfo memory setup) external;
 
     function getInstanceReader() external view returns (InstanceReader);

package/contracts/instance/Instance.sol

@@ -25,6 +25,7 @@ import {ERC165} from "../shared/ERC165.sol";
 import {Registerable} from "../shared/Registerable.sol";
 import {ComponentOwnerService} from "./service/ComponentOwnerService.sol";
 import {IComponentOwnerService} from "./service/IComponentOwnerService.sol";
+import {IDistributionService} from "./service/IDistributionService.sol";
 import {VersionPart} from "../types/Version.sol";
 
 contract Instance is
@@ -53,7 +54,6 @@ contract Instance is
     InstanceReader internal _instanceReader;
 
     constructor(address accessManagerAddress, address registryAddress, NftId registryNftId)
-        AccessManagedSimple(accessManagerAddress)
     {
         initialize(accessManagerAddress, registryAddress, registryNftId, msg.sender);
     }
@@ -61,6 +61,8 @@ contract Instance is
     function initialize(address accessManagerAddress, address registryAddress, NftId registryNftId, address initialOwner) public {
         require(!_initialized, "Contract instance has already been initialized");
 
+        initializeAccessManagedSimple(accessManagerAddress);
+
         _accessManager = AccessManagerSimple(accessManagerAddress);
         _createRole(RoleIdLib.toRoleId(ADMIN_ROLE), "AdminRole", false, false);
         _createRole(RoleIdLib.toRoleId(PUBLIC_ROLE), "PublicRole", false, false);
@@ -416,10 +418,9 @@ contract Instance is
         return ComponentOwnerService(_registry.getServiceAddress("ComponentOwnerService", VersionPart.wrap(3)));
     }
 
-    // TODO reactivate when services are available
-    // function getDistributionService() external view returns (IDistributionService) {
-    //     return DistributionService(_registry.getServiceAddress("DistributionService", VersionPart.wrap(3)));
-    // }
+    function getDistributionService() external view returns (IDistributionService) {
+        return IDistributionService(_registry.getServiceAddress("DistributionService", VersionPart.wrap(3)));
+    }
 
     // TODO reactivate when services are available
     // function getProductService() external view returns (IProductService) {

package/contracts/instance/InstanceAccessManager.sol

@@ -79,9 +79,9 @@ contract InstanceAccessManager is
     AccessManagerSimple internal _accessManager;
 
     constructor(address accessManager)
-        AccessManagedSimple(accessManager)
     {
         _accessManager = AccessManagerSimple(accessManager);
+        initializeAccessManagedSimple(accessManager);
 
         _createRole(RoleIdLib.toRoleId(_accessManager.ADMIN_ROLE()), ADMIN_ROLE_NAME, false, false);
         _createRole(RoleIdLib.toRoleId(_accessManager.PUBLIC_ROLE()), PUBLIC_ROLE_NAME, false, false);

package/contracts/instance/InstanceService.sol

@@ -16,6 +16,7 @@ import {IService} from "../shared/IService.sol";
 import {ContractDeployerLib} from "../shared/ContractDeployerLib.sol";
 import {NftId, NftIdLib, zeroNftId} from "../../contracts/types/NftId.sol";
 import {VersionLib} from "../types/Version.sol";
+import {ADMIN_ROLE, INSTANCE_SERVICE_ROLE} from "../types/RoleId.sol";
 
 contract InstanceService is Service, IInstanceService {
 
@@ -37,13 +38,15 @@ contract InstanceService is Service, IInstanceService {
             InstanceReader clonedInstanceReader
         )
     {
+        address instanceOwner = msg.sender;
         Registry registry = Registry(_registryAddress);
         NftId registryNftId = registry.getNftId(_registryAddress);
         address registryServiceAddress = registry.getServiceAddress("RegistryService", VersionLib.toVersion(3, 0, 0).toMajorPart());
         RegistryService registryService = RegistryService(registryServiceAddress);
 
         clonedAccessManager = AccessManagerSimple(Clones.clone(_accessManagerMaster));
-        clonedAccessManager.initialize(msg.sender);
+        // initial as this
+        clonedAccessManager.initialize(address(this));
 
         clonedInstance = Instance(Clones.clone(_instanceMaster));
         clonedInstance.initialize(address(clonedAccessManager), _registryAddress, registryNftId, msg.sender);
@@ -53,9 +56,30 @@ contract InstanceService is Service, IInstanceService {
         clonedInstanceReader = InstanceReader(Clones.clone(address(_instanceReaderMaster)));
         clonedInstanceReader.initialize(_registryAddress, instanceNftId);
 
+        _grantAuthorizations(clonedAccessManager, clonedInstance);
+
+        clonedInstance.setInstanceReader(clonedInstanceReader);
+
+        // switch instance ownership to instance owner
+        clonedAccessManager.grantRole(ADMIN_ROLE().toInt(), instanceOwner, 0);
+        clonedAccessManager.revokeRole(ADMIN_ROLE().toInt(), address(this));
+
         emit LogInstanceCloned(address(clonedAccessManager), address(clonedInstance), address(clonedInstanceReader), instanceNftId);
     }
 
+    function _grantAuthorizations(AccessManagerSimple clonedAccessManager, Instance clonedInstance) internal {
+        // grant initial permissions (if any)
+
+        // example
+        // clonedAccessManager.grantRole(INSTANCE_SERVICE_ROLE().toInt(), address(this), 0);
+        // bytes4[] memory instanceSetInstanceReaderSelectors = new bytes4[](1);
+        // instanceSetInstanceReaderSelectors[0] = clonedInstance.setInstanceReader.selector;
+        // clonedAccessManager.setTargetFunctionRole(
+        //     address(clonedInstance),
+        //     instanceSetInstanceReaderSelectors, 
+        //     INSTANCE_SERVICE_ROLE().toInt());
+    }
+
     function setAccessManagerMaster(address accessManagerMaster) external {
         require(
             _accessManagerMaster == address(0),

package/contracts/instance/base/ComponentServiceBase.sol

@@ -12,16 +12,6 @@ import {Version, VersionPart, VersionLib} from "../../types/Version.sol";
 
 abstract contract ComponentServiceBase is Service {
 
-    constructor(
-        address registry,
-        NftId registryNftId,
-        address initialOwner
-    )
-    {
-        _initializeService(registry, initialOwner);
-    }
-
-
     function _getAndVerifyComponentInfoAndInstance(
         ObjectType objectType
     )
@@ -32,7 +22,7 @@ abstract contract ComponentServiceBase is Service {
             IInstance instance
         )
     {
-        NftId componentNftId = getRegistry().getNftId(msg.sender);
+        NftId componentNftId = _registry.getNftId(msg.sender);
         require(componentNftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
 
         info = getRegistry().getObjectInfo(componentNftId);

package/contracts/instance/service/DistributionService.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IRegistryService} from "../../registry/IRegistryService.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+import {InstanceReader} from "../../instance/InstanceReader.sol";
+import {ISetup} from "../../instance/module/ISetup.sol";
+import {ITreasury} from "../../instance/module/ITreasury.sol";
+
+import {NftId, NftIdLib} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {KEEP_STATE} from "../../types/StateId.sol";
+import {DISTRIBUTION} from "../../types/ObjectType.sol";
+import {Version, VersionLib} from "../../types/Version.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 {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
+import {IDistributionService} from "./IDistributionService.sol";
+import {Distribution} from "../../components/Distribution.sol";
+
+string constant DISTRIBUTION_SERVICE_NAME = "DistributionService";
+
+contract DistributionService is
+    ComponentServiceBase,
+    IDistributionService
+{
+    using NftIdLib for NftId;
+
+    string public constant NAME = "DistributionService";
+
+    address internal _registryAddress;
+    
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        initializer
+        virtual override
+    {
+        address initialOwner = address(0);
+        (_registryAddress, initialOwner) = abi.decode(data, (address, address));
+
+        // IRegistry registry = IRegistry(_registryAddress);
+
+        _initializeService(_registryAddress, initialOwner);
+
+        _registerInterface(type(IService).interfaceId);
+        _registerInterface(type(IDistributionService).interfaceId);
+    }
+
+
+    function getName() public pure override(IService, Service) returns(string memory name) {
+        return NAME;
+    }
+
+    function register(address distributionComponentAddress, address componentOwner) 
+        external 
+        // TODO restricted 
+        returns (NftId distributionNftId)
+    {
+        // TODO validate permission of componentOwner
+        Distribution distribution = Distribution(distributionComponentAddress);
+        IRegistryService registryService = getRegistryService();
+        (IRegistry.ObjectInfo memory distributionObjInfo, ) = registryService.registerDistribution(
+            distribution,
+            componentOwner
+        );
+        distributionNftId = distributionObjInfo.nftId;
+
+        ISetup.DistributionSetupInfo memory initialSetup = distribution.getInitialSetupInfo();
+        IInstance instance = distribution.getInstance();
+        instance.createDistributionSetup(distributionNftId, initialSetup);
+    }
+
+    function setFees(
+        Fee memory distributionFee
+    )
+        external
+        override
+    {
+        (IRegistry.ObjectInfo memory info , IInstance instance) = _getAndVerifyComponentInfoAndInstance(DISTRIBUTION());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        NftId distributionNftId = info.nftId;
+
+        ISetup.DistributionSetupInfo memory distSetupInfo = instanceReader.getDistributionSetupInfo(distributionNftId);
+        distSetupInfo.distributionFee = distributionFee;
+        
+        instance.updateDistributionSetup(distributionNftId, distSetupInfo, KEEP_STATE());
+    }
+}

package/contracts/instance/service/DistributionServiceManager.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {ProxyManager} from "../../shared/ProxyManager.sol";
+import {DistributionService} from "./DistributionService.sol";
+import {Registry} from "../../registry/Registry.sol";
+import {RegistryService} from "../../registry/RegistryService.sol";
+import {VersionLib} from "../../types/Version.sol";
+
+contract DistributionServiceManager is ProxyManager {
+
+    DistributionService private _distributionService;
+
+    /// @dev initializes proxy manager with distribution service implementation and deploys instance
+    constructor(
+        address registryAddress
+    )
+        ProxyManager()
+    {
+        DistributionService distSrv = new DistributionService();
+        bytes memory data = abi.encode(registryAddress, address(this));
+        IVersionable versionable = deploy(
+            address(distSrv), 
+            data);
+
+        _distributionService = DistributionService(address(versionable));
+
+        Registry registry = Registry(registryAddress);
+        address registryServiceAddress = registry.getServiceAddress("RegistryService", VersionLib.toVersion(3, 0, 0).toMajorPart());
+        RegistryService registryService = RegistryService(registryServiceAddress);
+        
+        registryService.registerService(_distributionService);
+        
+        // link ownership of instance service manager ot nft owner of instance service
+        _linkToNftOwnable(
+            address(registryAddress),
+            address(_distributionService));
+
+        // implies that after this constructor call only upgrade functionality is available
+        _isDeployed = true;
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getDistributionService()
+        external
+        view
+        returns (DistributionService distributionService)
+    {
+        return _distributionService;
+    }
+
+}

package/contracts/registry/IRegistry.sol

@@ -10,10 +10,33 @@ import {VersionPart} from "../types/Version.sol";
 
 interface IRegistry is IERC165 {
 
+    event LogInitialMajorVersionSet(VersionPart majorVersion);
+    event LogMajorVersionSet(VersionPart majorVersionMax);
     event LogRegistration(ObjectInfo info);
-
+    event LogTokenStateSet(address token, VersionPart majorVersion, bool active);
     event LogServiceNameRegistration(string serviceName, VersionPart majorVersion); 
 
+    // supported versions
+    error MajorVersionMaxIncreaseInvalid(VersionPart newMajorVersionMax, VersionPart existingMaxMajorVersion);
+
+    // token whitelisting
+    error TokenNotRegistered(address token);
+    error NotToken(address token);
+    error TokenMajorVersionInvalid(VersionPart majorVersion);
+
+    // register
+    error NotRegistryService();
+    error ZeroParentAddress();
+    error ContractAlreadyRegistered(address objectAddress);
+    error InvalidServiceVersion(VersionPart majorVersion);
+    error ServiceNameAlreadyRegistered(string name, VersionPart majorVersion);
+            
+    // approve
+    error NotOwner(address account);
+    error NotRegisteredContract(NftId registrarNftId);
+    error NotService(NftId registrarNftId);
+    error InvalidTypesCombination(ObjectType objectType, ObjectType parentType);
+
 
     struct ObjectInfo {
         NftId nftId;
@@ -26,11 +49,22 @@ interface IRegistry is IERC165 {
     }// TODO delete nftId and initialOwner(if not used) from struct
     // TODO strong disagree, keep nftId there (lets keep get object info return object consistent)
 
+    function setMajorVersion(VersionPart newMajorVersionMax) external;
+
     function register(ObjectInfo memory info) external returns (NftId nftId);
-    
+
+    function setTokenActive(address token, VersionPart majorVersion, bool active) external;
+
+    function getMajorVersionMin() external view returns (VersionPart);
+
+    function getMajorVersionMax() external view returns (VersionPart);
+
+    function getMajorVersion() external view returns (VersionPart);
 
     function getObjectCount() external view returns (uint256);
 
+    function getNftId() external view returns (NftId nftId);
+
     function getNftId(address objectAddress) external view returns (NftId nftId);
 
     function ownerOf(NftId nftId) external view returns (address);
@@ -45,6 +79,8 @@ interface IRegistry is IERC165 {
 
     function isRegistered(address contractAddress) external view returns (bool);
 
+    function isTokenActive(address token, VersionPart majorVersion) external view returns (bool);
+
     function getServiceName(NftId nftId) external view returns (string memory name);
 
     function getServiceAddress(

package/contracts/registry/IRegistryService.sol

@@ -12,8 +12,6 @@ import {IBaseComponent} from "../components/IBaseComponent.sol";
 
 interface IRegistryService is IService {
 
-    function registerToken(address tokenAddress) external returns(NftId nftId);
-
     function registerService(IService service)  external returns(IRegistry.ObjectInfo memory info, bytes memory data);
 
     function registerInstance(IRegisterable instance)