refactor: adapt how we store subgraph metadata to make it easier to render into base58

Author: abarmat

contracts/discovery/GNS.sol

@@ -236,17 +236,7 @@ contract GNS is GNSV2Storage, GraphUpgradeable, IGNS, Multicall {
         override
         onlySubgraphAuth(_subgraphID)
     {
-        _updateSubgraphMetadata(_subgraphID, _subgraphMetadata);
-    }
-
-    /**
-     * @dev Internal: Allows a subgraph owner to update the metadata of a subgraph they have published
-     * @param _subgraphID Subgraph ID
-     * @param _subgraphMetadata IPFS hash for the subgraph metadata
-     */
-    function _updateSubgraphMetadata(uint256 _subgraphID, bytes32 _subgraphMetadata) internal {
-        _setSubgraphURI(_subgraphID, string(abi.encodePacked(_subgraphMetadata)));
-        emit SubgraphMetadataUpdated(_subgraphID, _subgraphMetadata);
+        _setSubgraphMetadata(_subgraphID, _subgraphMetadata);
     }
 
     /**
@@ -276,7 +266,7 @@ contract GNS is GNSV2Storage, GraphUpgradeable, IGNS, Multicall {
         emit SubgraphPublished(subgraphID, _subgraphDeploymentID, defaultReserveRatio);
 
         // Set the token metadata
-        _updateSubgraphMetadata(subgraphID, _subgraphMetadata);
+        _setSubgraphMetadata(subgraphID, _subgraphMetadata);
 
         emit SubgraphVersionUpdated(subgraphID, _subgraphDeploymentID, _versionMetadata);
     }
@@ -706,7 +696,7 @@ contract GNS is GNSV2Storage, GraphUpgradeable, IGNS, Multicall {
         emit LegacySubgraphClaimed(_graphAccount, _subgraphNumber);
 
         // Set the token metadata
-        _updateSubgraphMetadata(subgraphID, _subgraphMetadata);
+        _setSubgraphMetadata(subgraphID, _subgraphMetadata);
     }
 
     /**
@@ -789,19 +779,42 @@ contract GNS is GNSV2Storage, GraphUpgradeable, IGNS, Multicall {
 
     // -- NFT --
 
+    /**
+     * @dev Return the owner of a subgraph.
+     * @param _tokenID Subgraph ID
+     * @return Owner address
+     */
     function ownerOf(uint256 _tokenID) public view override returns (address) {
         return subgraphNFT.ownerOf(_tokenID);
     }
 
+    /**
+     * @dev Mint the NFT for the subgraph.
+     * @param _owner Owner address
+     * @param _tokenID Subgraph ID
+     */
     function _mintNFT(address _owner, uint256 _tokenID) internal {
         subgraphNFT.mint(_owner, _tokenID);
     }
 
+    /**
+     * @dev Burn the NFT for the subgraph.
+     * @param _tokenID Subgraph ID
+     */
     function _burnNFT(uint256 _tokenID) internal {
         subgraphNFT.burn(_tokenID);
     }
 
-    function _setSubgraphURI(uint256 _tokenID, string memory _subgraphURI) internal {
-        subgraphNFT.setSubgraphURI(_tokenID, _subgraphURI);
+    /**
+     * @dev Set the subgraph metadata.
+     * @param _tokenID Subgraph ID
+     * @param _subgraphMetadata IPFS hash of the subgraph metadata
+     */
+    function _setSubgraphMetadata(uint256 _tokenID, bytes32 _subgraphMetadata) internal {
+        subgraphNFT.setSubgraphMetadata(_tokenID, _subgraphMetadata);
+
+        // Even if the following event is emitted in the NFT we emit it here to facilitate
+        // subgraph indexing
+        emit SubgraphMetadataUpdated(_tokenID, _subgraphMetadata);
     }
 }

contracts/discovery/ISubgraphNFT.sol

@@ -19,7 +19,7 @@ interface ISubgraphNFT is IERC721 {
 
     function burn(uint256 _tokenId) external;
 
-    function setSubgraphURI(uint256 _tokenId, string memory _subgraphURI) external;
+    function setSubgraphMetadata(uint256 _tokenId, bytes32 _subgraphMetadata) external;
 
     function tokenURI(uint256 _tokenId) external view returns (string memory);
 }

contracts/discovery/ISubgraphNFTDescriptor.sol

@@ -5,14 +5,16 @@ pragma solidity ^0.7.6;
 /// @title Describes subgraph NFT tokens via URI
 interface ISubgraphNFTDescriptor {
     /// @notice Produces the URI describing a particular token ID for a Subgraph
-    /// @dev Note this URI may be a data: URI with the JSON contents directly inlined
+    /// @dev Note this URI may be data: URI with the JSON contents directly inlined
     /// @param _minter Address of the allowed minter
     /// @param _tokenId The ID of the subgraph NFT for which to produce a description, which may not be valid
+    /// @param _baseURI The base URI that could be prefixed to the final URI
+    /// @param _subgraphMetadata Subgraph metadata set for the subgraph
     /// @return The URI of the ERC721-compliant metadata
     function tokenURI(
         address _minter,
         uint256 _tokenId,
         string calldata _baseURI,
-        string calldata _tokenURI
+        bytes32 _subgraphMetadata
     ) external view returns (string memory);
 }

contracts/discovery/SubgraphNFT.sol

@@ -4,27 +4,25 @@ pragma solidity ^0.7.6;
 
 import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import "@openzeppelin/contracts/utils/Address.sol";
-import "@openzeppelin/contracts/utils/Strings.sol";
 
 import "../governance/Governed.sol";
+import "../libraries/HexStrings.sol";
 import "./ISubgraphNFT.sol";
 import "./ISubgraphNFTDescriptor.sol";
 
 /// @title NFT that represents ownership of a Subgraph
 contract SubgraphNFT is Governed, ERC721, ISubgraphNFT {
-    using Strings for uint256;
-
     // -- State --
 
     address public minter;
     ISubgraphNFTDescriptor public tokenDescriptor;
-    mapping(uint256 => string) private _subgraphURIs;
+    mapping(uint256 => bytes32) private _subgraphMetadataHashes;
 
     // -- Events --
 
     event MinterUpdated(address minter);
     event TokenDescriptorUpdated(address tokenDescriptor);
-    event SubgraphURIUpdated(uint256 indexed tokenID, string subgraphURI);
+    event SubgraphMetadataUpdated(uint256 indexed tokenID, bytes32 subgraphURI);
 
     // -- Modifiers --
 
@@ -111,18 +109,19 @@ contract SubgraphNFT is Governed, ERC721, ISubgraphNFT {
     }
 
     /**
-     * @notice Set the URI for a subgraph represented by `_tokenId`.
+     * @notice Set the metadata for a subgraph represented by `_tokenId`.
      * @dev `_tokenId` must exist.
      * @param _tokenId ID of the NFT
+     * @param _subgraphMetadata IPFS hash for the metadata
      */
-    function setSubgraphURI(uint256 _tokenId, string memory _subgraphURI)
+    function setSubgraphMetadata(uint256 _tokenId, bytes32 _subgraphMetadata)
         external
         override
         onlyMinter
     {
         require(_exists(_tokenId), "ERC721Metadata: URI set of nonexistent token");
-        _subgraphURIs[_tokenId] = _subgraphURI;
-        emit SubgraphURIUpdated(_tokenId, _subgraphURI);
+        _subgraphMetadataHashes[_tokenId] = _subgraphMetadata;
+        emit SubgraphMetadataUpdated(_tokenId, _subgraphMetadata);
     }
 
     // -- NFT display --
@@ -137,13 +136,21 @@ contract SubgraphNFT is Governed, ERC721, ISubgraphNFT {
         require(_exists(_tokenId), "ERC721Metadata: URI query for nonexistent token");
 
         // Delegates rendering of the metadata to the token descriptor if existing
-        // This allows for some flexibility in adapting the metadata
+        // This allows for some flexibility in adapting the token URI
         if (address(tokenDescriptor) != address(0)) {
-            return tokenDescriptor.tokenURI(minter, _tokenId, baseURI(), _subgraphURIs[_tokenId]);
+            return
+                tokenDescriptor.tokenURI(
+                    minter,
+                    _tokenId,
+                    baseURI(),
+                    _subgraphMetadataHashes[_tokenId]
+                );
         }
 
-        // Default metadata
-        string memory _subgraphURI = _subgraphURIs[_tokenId];
+        // Default token URI
+        uint256 metadata = uint256(_subgraphMetadataHashes[_tokenId]);
+
+        string memory _subgraphURI = metadata > 0 ? HexStrings.toString(metadata) : "";
         string memory base = baseURI();
 
         // If there is no base URI, return the token URI.
@@ -155,6 +162,6 @@ contract SubgraphNFT is Governed, ERC721, ISubgraphNFT {
             return string(abi.encodePacked(base, _subgraphURI));
         }
         // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
-        return string(abi.encodePacked(base, _tokenId.toString()));
+        return string(abi.encodePacked(base, HexStrings.toString(_tokenId)));
     }
 }

contracts/discovery/SubgraphNFTDescriptor.sol

@@ -2,17 +2,24 @@
 
 pragma solidity ^0.7.6;
 
+import "../libraries/Base58Encoder.sol";
 import "./ISubgraphNFTDescriptor.sol";
 
 /// @title Describes subgraph NFT tokens via URI
 contract SubgraphNFTDescriptor is ISubgraphNFTDescriptor {
     /// @inheritdoc ISubgraphNFTDescriptor
     function tokenURI(
-        address _minter,
-        uint256 _tokenId,
+        address, /* _minter */
+        uint256, /* _tokenId */
         string calldata _baseURI,
-        string calldata _subgraphURI
-    ) external view override returns (string memory) {
-        return string(abi.encodePacked(_baseURI, _subgraphURI));
+        bytes32 _subgraphMetadata
+    ) external pure override returns (string memory) {
+        bytes memory b58 = Base58Encoder.encode(
+            abi.encodePacked(Base58Encoder.sha256MultiHash, _subgraphMetadata)
+        );
+        if (bytes(_baseURI).length == 0) {
+            return string(b58);
+        }
+        return string(abi.encodePacked(_baseURI, b58));
     }
 }

contracts/libraries/Base58Encoder.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+pragma solidity ^0.7.6;
+
+/// @title Base58Encoder
+/// @author Original author - Martin Lundfall ([email protected])
+/// Based on https://github.com/MrChico/verifyIPFS
+library Base58Encoder {
+    bytes constant sha256MultiHash = hex"1220";
+    bytes constant ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+    /// @dev Converts hex string to base 58
+    function encode(bytes memory source) internal pure returns (bytes memory) {
+        if (source.length == 0) return new bytes(0);
+        uint8[] memory digits = new uint8[](64);
+        digits[0] = 0;
+        uint8 digitlength = 1;
+        for (uint256 i = 0; i < source.length; ++i) {
+            uint256 carry = uint8(source[i]);
+            for (uint256 j = 0; j < digitlength; ++j) {
+                carry += uint256(digits[j]) * 256;
+                digits[j] = uint8(carry % 58);
+                carry = carry / 58;
+            }
+
+            while (carry > 0) {
+                digits[digitlength] = uint8(carry % 58);
+                digitlength++;
+                carry = carry / 58;
+            }
+        }
+        return toAlphabet(reverse(truncate(digits, digitlength)));
+    }
+
+    function truncate(uint8[] memory array, uint8 length) internal pure returns (uint8[] memory) {
+        uint8[] memory output = new uint8[](length);
+        for (uint256 i = 0; i < length; i++) {
+            output[i] = array[i];
+        }
+        return output;
+    }
+
+    function reverse(uint8[] memory input) internal pure returns (uint8[] memory) {
+        uint8[] memory output = new uint8[](input.length);
+        for (uint256 i = 0; i < input.length; i++) {
+            output[i] = input[input.length - 1 - i];
+        }
+        return output;
+    }
+
+    function toAlphabet(uint8[] memory indices) internal pure returns (bytes memory) {
+        bytes memory output = new bytes(indices.length);
+        for (uint256 i = 0; i < indices.length; i++) {
+            output[i] = ALPHABET[indices[i]];
+        }
+        return output;
+    }
+}

contracts/libraries/HexStrings.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+pragma solidity ^0.7.6;
+
+/// @title HexStrings
+/// Based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/8dd744fc1843d285c38e54e9d439dea7f6b93495/contracts/utils/Strings.sol
+library HexStrings {
+    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
+
+    /// @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
+    function toString(uint256 value) internal pure returns (string memory) {
+        if (value == 0) {
+            return "0x00";
+        }
+        uint256 temp = value;
+        uint256 length = 0;
+        while (temp != 0) {
+            length++;
+            temp >>= 8;
+        }
+        return toHexString(value, length);
+    }
+
+    /// @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
+    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
+        bytes memory buffer = new bytes(2 * length + 2);
+        buffer[0] = "0";
+        buffer[1] = "x";
+        for (uint256 i = 2 * length + 1; i > 1; --i) {
+            buffer[i] = _HEX_SYMBOLS[value & 0xf];
+            value >>= 4;
+        }
+        require(value == 0, "Strings: hex length insufficient");
+        return string(buffer);
+    }
+}

package.json

@@ -43,7 +43,6 @@
     "@typescript-eslint/typescript-estree": "^4.0.0",
     "@urql/core": "^2.1.3",
     "axios": "^0.21.1",
-    "base64-sol": "^1.1.0",
     "bignumber.js": "^9.0.0",
     "chai": "^4.3.4",
     "cli-table": "^0.3.6",