Fix for contract published metadata registering + enable linking to previous implementation (#205)

joaquim-verges · web-flow · commit 84bd28f3e904 · 2022-08-11T14:28:36.000-07:00
* fix multiple version backtracking + introduce linkback mechanism

* add unit test

* add another test for linked publishers

* fix list appending logic
diff --git a/contracts/ContractPublisher.sol b/contracts/ContractPublisher.sol
@@ -19,6 +19,7 @@ contract ContractPublisher is IContractPublisher, ERC2771Context, AccessControlE
 
     /// @notice Whether the contract publisher is paused.
     bool public isPaused;
+    IContractPublisher public prevPublisher;
 
     /*///////////////////////////////////////////////////////////////
                                 Mappings
@@ -49,8 +50,9 @@ contract ContractPublisher is IContractPublisher, ERC2771Context, AccessControlE
         _;
     }
 
-    constructor(address _trustedForwarder) ERC2771Context(_trustedForwarder) {
+    constructor(address _trustedForwarder, IContractPublisher _prevPublisher) ERC2771Context(_trustedForwarder) {
         _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
+        prevPublisher = _prevPublisher;
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -63,13 +65,19 @@ contract ContractPublisher is IContractPublisher, ERC2771Context, AccessControlE
         view
         returns (CustomContractInstance[] memory published)
     {
-        uint256 total = EnumerableSet.length(contractsOfPublisher[_publisher].contractIds);
-
+        CustomContractInstance[] memory linkedData = prevPublisher.getAllPublishedContracts(_publisher);
+        uint256 currentTotal = EnumerableSet.length(contractsOfPublisher[_publisher].contractIds);
+        uint256 prevTotal = linkedData.length;
+        uint256 total = prevTotal + currentTotal;
         published = new CustomContractInstance[](total);
-
-        for (uint256 i = 0; i < total; i += 1) {
+        // fill in previously published contracts
+        for (uint256 i = 0; i < prevTotal; i += 1) {
+            published[i] = linkedData[i];
+        }
+        // fill in current published contracts
+        for (uint256 i = 0; i < currentTotal; i += 1) {
             bytes32 contractId = EnumerableSet.at(contractsOfPublisher[_publisher].contractIds, i);
-            published[i] = contractsOfPublisher[_publisher].contracts[contractId].latest;
+            published[i + prevTotal] = contractsOfPublisher[_publisher].contracts[contractId].latest;
         }
     }
 
@@ -79,13 +87,25 @@ contract ContractPublisher is IContractPublisher, ERC2771Context, AccessControlE
         view
         returns (CustomContractInstance[] memory published)
     {
+        CustomContractInstance[] memory linkedVersions = prevPublisher.getPublishedContractVersions(
+            _publisher,
+            _contractId
+        );
+        uint256 prevTotal = linkedVersions.length;
+
         bytes32 id = keccak256(bytes(_contractId));
-        uint256 total = contractsOfPublisher[_publisher].contracts[id].total;
+        uint256 currentTotal = contractsOfPublisher[_publisher].contracts[id].total;
+        uint256 total = prevTotal + currentTotal;
 
         published = new CustomContractInstance[](total);
 
-        for (uint256 i = 0; i < total; i += 1) {
-            published[i] = contractsOfPublisher[_publisher].contracts[id].instances[i];
+        // fill in previously published contracts
+        for (uint256 i = 0; i < prevTotal; i += 1) {
+            published[i] = linkedVersions[i];
+        }
+        // fill in current published contracts
+        for (uint256 i = 0; i < currentTotal; i += 1) {
+            published[i + prevTotal] = contractsOfPublisher[_publisher].contracts[id].instances[i];
         }
     }
 
@@ -96,6 +116,10 @@ contract ContractPublisher is IContractPublisher, ERC2771Context, AccessControlE
         returns (CustomContractInstance memory published)
     {
         published = contractsOfPublisher[_publisher].contracts[keccak256(bytes(_contractId))].latest;
+        // if not found, check the previous publisher
+        if (published.publishTimestamp == 0) {
+            published = prevPublisher.getPublishedContract(_publisher, _contractId);
+        }
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -129,7 +153,7 @@ contract ContractPublisher is IContractPublisher, ERC2771Context, AccessControlE
         contractsOfPublisher[_publisher].contracts[contractIdInBytes].instances[index] = publishedContract;
 
         uint256 metadataIndex = compilerMetadataUriToPublishedMetadataUris[_compilerMetadataUri].index;
-        compilerMetadataUriToPublishedMetadataUris[_compilerMetadataUri].uris[index] = _publishMetadataUri;
+        compilerMetadataUriToPublishedMetadataUris[_compilerMetadataUri].uris[metadataIndex] = _publishMetadataUri;
         compilerMetadataUriToPublishedMetadataUris[_compilerMetadataUri].index = metadataIndex + 1;
 
         emit ContractPublished(_msgSender(), _publisher, publishedContract);
@@ -159,6 +183,10 @@ contract ContractPublisher is IContractPublisher, ERC2771Context, AccessControlE
     // @notice Get a publisher profile uri
     function getPublisherProfileUri(address publisher) public view returns (string memory uri) {
         uri = profileUriOfPublisher[publisher];
+        // if not found, check the previous publisher
+        if (bytes(uri).length == 0) {
+            uri = prevPublisher.getPublisherProfileUri(publisher);
+        }
     }
 
     /// @notice Retrieve the published metadata URI from a compiler metadata URI
@@ -167,10 +195,20 @@ contract ContractPublisher is IContractPublisher, ERC2771Context, AccessControlE
         view
         returns (string[] memory publishedMetadataUris)
     {
-        uint256 length = compilerMetadataUriToPublishedMetadataUris[compilerMetadataUri].index;
-        publishedMetadataUris = new string[](length);
-        for (uint256 i = 0; i < length; i += 1) {
-            publishedMetadataUris[i] = compilerMetadataUriToPublishedMetadataUris[compilerMetadataUri].uris[i];
+        string[] memory linkedUris = prevPublisher.getPublishedUriFromCompilerUri(compilerMetadataUri);
+        uint256 prevTotal = linkedUris.length;
+        uint256 currentTotal = compilerMetadataUriToPublishedMetadataUris[compilerMetadataUri].index;
+        uint256 total = prevTotal + currentTotal;
+        publishedMetadataUris = new string[](total);
+        // fill in previously published uris
+        for (uint256 i = 0; i < prevTotal; i += 1) {
+            publishedMetadataUris[i] = linkedUris[i];
+        }
+        // fill in current published uris
+        for (uint256 i = 0; i < currentTotal; i += 1) {
+            publishedMetadataUris[i + prevTotal] = compilerMetadataUriToPublishedMetadataUris[compilerMetadataUri].uris[
+                i
+            ];
         }
     }
 
diff --git a/docs/ContractPublisher.md b/docs/ContractPublisher.md
@@ -307,6 +307,23 @@ function multicall(bytes[] data) external nonpayable returns (bytes[] results)
 |---|---|---|
 | results | bytes[] | undefined
 
+### prevPublisher
+
+```solidity
+function prevPublisher() external view returns (contract IContractPublisher)
+```
+
+
+
+
+
+
+#### Returns
+
+| Name | Type | Description |
+|---|---|---|
+| _0 | contract IContractPublisher | undefined
+
 ### publishContract
 
 ```solidity
diff --git a/src/test/ContractPublisher.t.sol b/src/test/ContractPublisher.t.sol
@@ -149,6 +149,59 @@ contract ContractPublisherTest is BaseTest, IContractPublisherData {
         );
     }
 
+    function test_publish_multiple_versions() public {
+        string memory contractId = "MyContract";
+
+        vm.prank(publisher);
+        byoc.publishContract(
+            publisher,
+            contractId,
+            publishMetadataUri,
+            compilerMetadataUri,
+            keccak256(type(MockCustomContract).creationCode),
+            address(0)
+        );
+        string[] memory resolved = byoc.getPublishedUriFromCompilerUri(compilerMetadataUri);
+        assertEq(resolved.length, 1);
+        assertEq(resolved[0], publishMetadataUri);
+
+        string memory otherUri = "ipfs://abcd";
+        vm.prank(publisher);
+        byoc.publishContract(
+            publisher,
+            contractId,
+            publishMetadataUri,
+            otherUri,
+            keccak256(type(MockCustomContract).creationCode),
+            address(0)
+        );
+
+        string[] memory resolved2 = byoc.getPublishedUriFromCompilerUri(otherUri);
+        assertEq(resolved2.length, 1);
+        assertEq(resolved2[0], publishMetadataUri);
+    }
+
+    function test_read_from_linked_publisher() public {
+        IContractPublisher.CustomContractInstance[] memory contracts = byoc.getAllPublishedContracts(publisher);
+        assertEq(contracts.length, 1);
+        assertEq(contracts[0].contractId, "MockContract");
+
+        string memory contractId = "MyContract";
+        vm.prank(publisher);
+        byoc.publishContract(
+            publisher,
+            contractId,
+            publishMetadataUri,
+            compilerMetadataUri,
+            keccak256(type(MockCustomContract).creationCode),
+            address(0)
+        );
+        IContractPublisher.CustomContractInstance[] memory contracts2 = byoc.getAllPublishedContracts(publisher);
+        assertEq(contracts2.length, 2);
+        assertEq(contracts2[0].contractId, "MockContract");
+        assertEq(contracts2[1].contractId, "MyContract");
+    }
+
     // Deprecated
     // function test_publish_emit_ContractPublished() public {
     //     string memory contractId = "MyContract";
diff --git a/src/test/mocks/MockContractPublisher.sol b/src/test/mocks/MockContractPublisher.sol
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+import "../../../contracts/interfaces/IContractPublisher.sol";
+
+// solhint-disable const-name-snakecase
+contract MockContractPublisher is IContractPublisher {
+    function getAllPublishedContracts(address publisher)
+        external
+        view
+        override
+        returns (CustomContractInstance[] memory published)
+    {
+        CustomContractInstance[] memory mocks = new CustomContractInstance[](1);
+        mocks[0] = CustomContractInstance(
+            "MockContract",
+            123,
+            "ipfs://mock",
+            0x0000000000000000000000000000000000000000000000000000000000000001,
+            address(0x0000000000000000000000000000000000000000)
+        );
+        return mocks;
+    }
+
+    /**
+     *  @notice Returns all versions of a published contract.
+     *
+     *  @param publisher  The address of the publisher.
+     *  @param contractId The identifier for a published contract (that can have multiple verisons).
+     *
+     *  @return published The desired contracts published by the publisher.
+     */
+    function getPublishedContractVersions(address publisher, string memory contractId)
+        external
+        view
+        returns (CustomContractInstance[] memory published)
+    {
+        return new CustomContractInstance[](0);
+    }
+
+    /**
+     *  @notice Returns the latest version of a contract published by a publisher.
+     *
+     *  @param publisher  The address of the publisher.
+     *  @param contractId The identifier for a published contract (that can have multiple verisons).
+     *
+     *  @return published The desired contract published by the publisher.
+     */
+    function getPublishedContract(address publisher, string memory contractId)
+        external
+        view
+        returns (CustomContractInstance memory published)
+    {
+        return CustomContractInstance("", 0, "", "", address(0));
+    }
+
+    /**
+     *  @notice Let's an account publish a contract.
+     *
+     *  @param publisher           The address of the publisher.
+     *  @param contractId          The identifier for a published contract (that can have multiple verisons).
+     *  @param publishMetadataUri  The IPFS URI of the publish metadata.
+     *  @param compilerMetadataUri The IPFS URI of the compiler metadata.
+     *  @param bytecodeHash        The keccak256 hash of the contract bytecode.
+     *  @param implementation      (Optional) An implementation address that proxy contracts / clones can point to. Default value
+     *                             if such an implementation does not exist - address(0);
+     */
+    function publishContract(
+        address publisher,
+        string memory contractId,
+        string memory publishMetadataUri,
+        string memory compilerMetadataUri,
+        bytes32 bytecodeHash,
+        address implementation
+    ) external {}
+
+    /**
+     *  @notice Lets a publisher unpublish a contract and all its versions.
+     *
+     *  @param publisher  The address of the publisher.
+     *  @param contractId The identifier for a published contract (that can have multiple verisons).
+     */
+    function unpublishContract(address publisher, string memory contractId) external {}
+
+    /**
+     * @notice Lets an account set its publisher profile uri
+     */
+    function setPublisherProfileUri(address publisher, string memory uri) external {}
+
+    /**
+     * @notice Get the publisher profile uri for a given publisher.
+     */
+    function getPublisherProfileUri(address publisher) external view returns (string memory uri) {
+        return "";
+    }
+
+    /**
+     * @notice Retrieve the published metadata URI from a compiler metadata URI.
+     */
+    function getPublishedUriFromCompilerUri(string memory compilerMetadataUri)
+        external
+        view
+        returns (string[] memory publishedMetadataUris)
+    {
+        return new string[](0);
+    }
+}
diff --git a/src/test/utils/BaseTest.sol b/src/test/utils/BaseTest.sol
@@ -9,6 +9,7 @@ import "../mocks/WETH9.sol";
 import "../mocks/MockERC20.sol";
 import "../mocks/MockERC721.sol";
 import "../mocks/MockERC1155.sol";
+import "../mocks/MockContractPublisher.sol";
 import "contracts/Forwarder.sol";
 import "contracts/TWFee.sol";
 import "contracts/TWRegistry.sol";
@@ -26,6 +27,7 @@ import { Marketplace } from "contracts/marketplace/Marketplace.sol";
 import { VoteERC20 } from "contracts/vote/VoteERC20.sol";
 import { SignatureDrop } from "contracts/signature-drop/SignatureDrop.sol";
 import { ContractPublisher } from "contracts/ContractPublisher.sol";
+import { IContractPublisher } from "contracts/interfaces/IContractPublisher.sol";
 import "contracts/mock/Mock.sol";
 
 abstract contract BaseTest is DSTest, Test {
@@ -72,7 +74,7 @@ abstract contract BaseTest is DSTest, Test {
         forwarder = address(new Forwarder());
         registry = address(new TWRegistry(forwarder));
         factory = address(new TWFactory(forwarder, registry));
-        contractPublisher = address(new ContractPublisher(forwarder));
+        contractPublisher = address(new ContractPublisher(forwarder, new MockContractPublisher()));
         TWRegistry(registry).grantRole(TWRegistry(registry).OPERATOR_ROLE(), factory);
         TWRegistry(registry).grantRole(TWRegistry(registry).OPERATOR_ROLE(), contractPublisher);
         fee = address(new TWFee(forwarder, factory));
