merged versioned distributor with simple distributor interfaces (#9)

* merged versioned distributor with simple distributor interfaces, replaced getmetadata with contract uri

* happy linter - happy life

* change abstract instantiate fn to internal visibility

* made instantiate internal in abstract contracts

Author: peersky

.changeset/violet-suits-roll.md

@@ -0,0 +1,44 @@
+---
+"@peeramid-labs/eds": major
+---
+
+# Breaking changes
+
+## Deprecated getMetadata in favor of contractURI
+
+contractURI is more widely used and we want to align with the standard.
+
+
+## Merged VersionedDistributor into Distributor
+
+Now there is only a single `IDistributor` interface. Distribution creators still have two methods of adding distributions - either by specifying repository address, or by specifying a distribution hash id directly.
+
+The `VersionedDistributor` is now deprecated and will be removed in the next major version.
+
+Instantiation function will now automatically detect if the provided address is a repository or a distribution id and call the appropriate method.
+
+ERC7746 checks will now also automatically detect if the provided address is a repository or a distribution and will enforce version control accordingly.
+
+### Instantiated event
+
+Now emits also a version indexed parameter, arshHash was removed, args are availible as not indexed object in data
+
+## addDistribution for versioned repositories
+
+`addDistribution` now takes `LibSemver.VersionRequirement` as an argument, which is more convenient way to pack both version and requirement in a single argument.
+
+## Repository now requires cURI
+
+The `cURI` is now required for all repositories. This is to ensure that all repositories are compliant with the standard contractURI method
+
+## Reposotory `get` function
+
+Repostory `get` function now takes `LibSemver.VersionRequirement` as an argument, which is more convenient way to pack both version and requirement in a single argument.
+
+## LibSemver.compare
+
+`compare` now takes `LibSemver.VersionRequirement` as an argument, which is more convenient way to pack both version and requirement in a single argument.
+
+## LibSemver compare(version version) -> areEqual
+
+`compare(Version memory _version1, Version memory _version2)` now returns a boolean instead of an integer.

src/abstracts/CloneDistribution.sol

@@ -11,9 +11,11 @@ abstract contract CloneDistribution is IDistribution, CodeIndexer {
     function sources() internal view virtual returns (address[] memory, bytes32 name, uint256 version);
 
     // @inheritdoc IDistribution
-    function instantiate(
-        bytes memory
-    ) external virtual returns (address[] memory instances, bytes32 distributionName, uint256 distributionVersion) {
+    function _instantiate()
+        internal
+        virtual
+        returns (address[] memory instances, bytes32 distributionName, uint256 distributionVersion)
+    {
         (address[] memory _sources, bytes32 _distributionName, uint256 _distributionVersion) = sources();
         uint256 srcsLength = _sources.length;
         instances = new address[](srcsLength);
@@ -29,5 +31,5 @@ abstract contract CloneDistribution is IDistribution, CodeIndexer {
         return sources();
     }
     // @inheritdoc IDistribution
-    function getMetadata() external view virtual returns (string memory);
+    function contractURI() external view virtual returns (string memory);
 }

src/abstracts/Distributor.sol

@@ -7,6 +7,8 @@ import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import "../interfaces/IInitializer.sol";
 import "../abstracts/CodeIndexer.sol";
 import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+import {IContractURI} from "../interfaces/IContractURI.sol";
 /**
  * @title Distributor
  * @notice Abstract contract that implements the IDistributor interface, CodeIndexer, and ERC165.
@@ -15,16 +17,24 @@ import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
  * @author Peeramid Labs, 2024
  */
 abstract contract Distributor is IDistributor, CodeIndexer, ERC165 {
+    using LibSemver for LibSemver.Version;
     struct DistributionComponent {
-        bytes32 id;
+        address distributionLocation;
         address initializer;
     }
+
+    struct VersionedDistribution {
+        LibSemver.VersionRequirement requirement;
+    }
+
     using EnumerableSet for EnumerableSet.Bytes32Set;
     EnumerableSet.Bytes32Set private distirbutionsSet;
-    // mapping(bytes32 => IInitializer) private initializers;
-    mapping(address => uint256) private instanceIds;
-    mapping(uint256 => bytes32) public distributionOf;
-    mapping(bytes32 => DistributionComponent) public distributionComponents;
+    mapping(address instance => uint256 instanceId) private instanceIds;
+    mapping(uint256 instance => bytes32 distributorsId) public distributionOf;
+    mapping(bytes32 distributorsId => DistributionComponent distirbution) public distributionComponents;
+    mapping(bytes32 distributorsId => LibSemver.VersionRequirement VersionRequirement) public versionRequirements;
+    mapping(uint256 instanceId => LibSemver.Version instanceVersion) public instanceVersions;
+
     uint256 public numInstances;
     // @inheritdoc IDistributor
     function getDistributions() external view returns (bytes32[] memory) {
@@ -41,43 +51,94 @@ abstract contract Distributor is IDistributor, CodeIndexer, ERC165 {
     // @inheritdoc IDistributor
     function getDistributionURI(bytes32 distributorsId) external view returns (string memory) {
         DistributionComponent memory distributionComponent = distributionComponents[distributorsId];
-        ICodeIndex codeIndex = getContractsIndex();
-        return IDistribution(codeIndex.get(distributionComponent.id)).getMetadata();
+        return IContractURI(distributionComponent.distributionLocation).contractURI();
     }
 
-    function _addDistribution(bytes32 id, address initializerAddress) internal virtual {
+    function _addDistribution(
+        address repository,
+        address initializer,
+        LibSemver.VersionRequirement memory requirement
+    ) internal {
+        if (!ERC165Checker.supportsInterface(address(repository), type(IRepository).interfaceId)) {
+            revert InvalidRepository(repository);
+        }
+        bytes32 distributorId = keccak256(abi.encode(repository, initializer));
+        if (LibSemver.toUint256(requirement.version) == 0) {
+            revert InvalidVersionRequested(distributorId, LibSemver.toString(requirement.version));
+        }
+        _newDistriubutionRecord(distributorId, repository, initializer);
+        versionRequirements[distributorId] = requirement;
+        emit VersionChanged(distributorId, requirement, requirement);
+    }
+
+    function _newDistriubutionRecord(bytes32 distributorId, address source, address initializer) private {
+        if (distirbutionsSet.contains(distributorId)) revert DistributionExists(distributorId);
+        distirbutionsSet.add(distributorId);
+        distributionComponents[distributorId] = DistributionComponent(source, initializer);
+        emit DistributionAdded(distributorId, source, initializer);
+    }
+    function _addDistribution(bytes32 id, address initializerAddress) internal {
         ICodeIndex codeIndex = getContractsIndex();
-        if (codeIndex.get(id) == address(0)) revert DistributionNotFound(id);
+        address distributionLocation = codeIndex.get(id);
+        if (distributionLocation == address(0)) revert DistributionNotFound(id);
         bytes32 distributorsId = keccak256(abi.encode(id, initializerAddress));
-        if (distirbutionsSet.contains(distributorsId)) revert DistributionExists(distributorsId);
-        distirbutionsSet.add(distributorsId);
-        distributionComponents[distributorsId] = DistributionComponent(id, initializerAddress);
-        emit DistributionAdded(id, initializerAddress);
+        _newDistriubutionRecord(distributorsId, distributionLocation, initializerAddress);
     }
 
     function _removeDistribution(bytes32 distributorsId) internal virtual {
         if (!distirbutionsSet.contains(distributorsId)) revert DistributionNotFound(distributorsId);
         distirbutionsSet.remove(distributorsId);
         delete distributionComponents[distributorsId];
+        delete versionRequirements[distributorsId];
         emit DistributionRemoved(distributorsId);
     }
 
     /**
      * @notice Internal function to instantiate a new instance.
-     * @dev WARNING: This function will DELEGATECALL to initializer. Initializer MUST be trusted contract.
+     * @dev WARNING: This function will DELEGATECALL to initializer if such is provided. Initializer contract MUST be trusted by distributor.
      */
     function _instantiate(
         bytes32 distributorsId,
         bytes memory args
     ) internal virtual returns (address[] memory instances, bytes32 distributionName, uint256 distributionVersion) {
-        ICodeIndex codeIndex = getContractsIndex();
         if (!distirbutionsSet.contains(distributorsId)) revert DistributionNotFound(distributorsId);
         DistributionComponent memory distributionComponent = distributionComponents[distributorsId];
+        LibSemver.VersionRequirement memory versionRequirement = versionRequirements[distributorsId];
+
+        // External initializer is provided, delegatecall to it
+        // Countrary, if no initializer is provided, the distribution is expected to be self-initializing
+        bool externallyInitialized = distributionComponent.initializer == address(0);
         bytes4 selector = IInitializer.initialize.selector;
-        // bytes memory instantiationArgs = initializer != address(0) ? args : bytes ("");
-        (instances, distributionName, distributionVersion) = IDistribution(codeIndex.get(distributionComponent.id))
-            .instantiate(args);
-        if (distributionComponent.initializer != address(0)) {
+        bytes memory instantiationArgs = externallyInitialized ? args : bytes("");
+        address distributionLocation;
+        numInstances++;
+        uint256 instanceId = numInstances;
+
+        if (LibSemver.toUint256(versionRequirement.version) == 0) {
+            // Unversioned distribution, expect IDistribution
+            distributionLocation = distributionComponent.distributionLocation;
+            // Name and version are inferred from what the distribution provides
+            (instances, distributionName, distributionVersion) = IDistribution(distributionLocation).instantiate(
+                instantiationArgs
+            );
+            // Unversioned distributions are considered to be at version 0, and are not expected to change
+            // This might change in the future, as it could make sence to inherit `distributionVersion` from the distribution
+            // Yet for ease of runtime validation and to avoid potential issues, we keep it at 0
+            instanceVersions[numInstances] = LibSemver.parse(0);
+        } else {
+            // Versioned distribution, expect IRepository
+            IRepository repository = IRepository(distributionComponent.distributionLocation);
+            IRepository.Source memory repoSource = repository.get(versionRequirement);
+            ICodeIndex codeIndex = getContractsIndex();
+            distributionLocation = codeIndex.get(repoSource.sourceId);
+            if (distributionLocation == address(0)) revert DistributionNotFound(repoSource.sourceId);
+            (instances, , ) = IDistribution(distributionLocation).instantiate(instantiationArgs);
+            distributionName = repository.repositoryName();
+            distributionVersion = LibSemver.toUint256(repoSource.version);
+            instanceVersions[numInstances] = repoSource.version;
+        }
+
+        if (externallyInitialized) {
             (bool success, bytes memory result) = address(distributionComponent.initializer).delegatecall(
                 abi.encodeWithSelector(selector, instances, args)
             );
@@ -92,15 +153,15 @@ abstract contract Distributor is IDistributor, CodeIndexer, ERC165 {
                 }
             }
         }
-        numInstances++;
-        uint256 instanceId = numInstances;
-        uint256 instancesLength = instances.length;
-        for (uint256 i; i < instancesLength; ++i) {
-            instanceIds[instances[i]] = instanceId;
-            distributionOf[instanceId] = distributorsId;
+
+        {
+            uint256 instancesLength = instances.length;
+            for (uint256 i; i < instancesLength; ++i) {
+                instanceIds[instances[i]] = instanceId;
+                distributionOf[instanceId] = distributorsId;
+            }
         }
-        emit Instantiated(distributorsId, instanceId, args, instances);
-        return (instances, distributionName, distributionVersion);
+        emit Instantiated(distributorsId, instanceId, distributionVersion, instances, args);
     }
 
     /**
@@ -117,13 +178,17 @@ abstract contract Distributor is IDistributor, CodeIndexer, ERC165 {
     ) external view virtual returns (bytes memory) {
         address target = config.length > 0 ? abi.decode(config, (address)) : msg.sender;
         bytes32 distributorsId = distributionOf[getInstanceId(maybeInstance)];
+        uint256 instanceId = getInstanceId(maybeInstance);
         if (
             distributorsId != bytes32(0) &&
-            getInstanceId(target) == getInstanceId(maybeInstance) &&
+            getInstanceId(target) == instanceId &&
             distirbutionsSet.contains(distributorsId)
         ) {
             // ToDo: This check could be based on DistributionOf, hence allowing cross-instance calls
             // Use layerConfig to allow client to configure requirement for the call
+            if (!LibSemver.compare(instanceVersions[instanceId], versionRequirements[distributorsId])) {
+                revert VersionOutdated(distributorsId, LibSemver.toString(instanceVersions[instanceId]));
+            }
             return abi.encode(distributorsId, "");
         }
         revert InvalidInstance(maybeInstance);
@@ -143,12 +208,31 @@ abstract contract Distributor is IDistributor, CodeIndexer, ERC165 {
     ) external virtual {
         address target = config.length > 0 ? abi.decode(config, (address)) : msg.sender;
         bytes32 distributorsId = distributionOf[getInstanceId(maybeInstance)];
+        uint256 instanceId = getInstanceId(maybeInstance);
         if ((getInstanceId(target) != getInstanceId(maybeInstance)) && distirbutionsSet.contains(distributorsId)) {
             revert InvalidInstance(maybeInstance);
         }
+        if (!LibSemver.compare(instanceVersions[instanceId], versionRequirements[distributorsId])) {
+            revert VersionOutdated(distributorsId, LibSemver.toString(instanceVersions[instanceId]));
+        }
     }
 
     function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
         return interfaceId == type(IDistributor).interfaceId || super.supportsInterface(interfaceId);
     }
+
+    function _changeVersion(bytes32 distributionId, LibSemver.VersionRequirement memory newRequirement) internal {
+        if (!distirbutionsSet.contains(distributionId)) revert DistributionNotFound(distributionId);
+        LibSemver.VersionRequirement memory oldRequirement = versionRequirements[distributionId];
+        if (LibSemver.toUint256(oldRequirement.version) == 0) {
+            revert UniversionedDistribution(distributionId);
+        }
+        if (LibSemver.toUint256(newRequirement.version) == 0) {
+            revert InvalidVersionRequested(distributionId, LibSemver.toString(newRequirement.version));
+        }
+        if (LibSemver.areEqual(oldRequirement.version, newRequirement.version)) {
+            revert InvalidVersionRequested(distributionId, LibSemver.toString(newRequirement.version));
+        }
+        versionRequirements[distributionId] = newRequirement;
+    }
 }