@artblocks/contracts 1.0.2 → 1.0.4

package/contracts/engine/V3/forks/PROHIBITION/interfaces/IAdminACLV0_PROHIBITION.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import "../../../../../interfaces/v0.8.x/IAdminACLV0.sol";
+
+interface IAdminACLV0_PROHIBITION is IAdminACLV0 {
+    /**
+     * @notice Emitted when function caller is updated.
+     * @param contractAddress Contract that the selector caller is being set for.
+     * @param selector Selector of the function we're giving the privilege to call.
+     * @param caller Caller address that is allowed to call the function.
+     * @param approved Boolean value indicating if the caller is approved or not.
+     */
+    event ContractSelectorApprovalUpdated(
+        address indexed contractAddress,
+        bytes4 indexed selector,
+        address indexed caller,
+        bool approved
+    );
+
+    /**
+     * @notice Emitted when verified artist is updated.
+     * @param contractAddress Contract that the selector caller is being set for.
+     * @param caller Address of the artist.
+     * @param approved Boolean value indicating if the caller is approved or not.
+     */
+    event ContractArtistApprovalUpdated(
+        address indexed contractAddress,
+        address indexed caller,
+        bool approved
+    );
+
+    /**
+     * @notice Retrieve whether of the caller is allowed to call a contract's function
+     * @param _contract The contract address.
+     * @param _selector The function selector.
+     * @param _caller The caller address.
+     * @return isApproved The approval status.
+     */
+    function getContractSelectorApproval(
+        address _contract,
+        bytes4 _selector,
+        address _caller
+    ) external view returns (bool);
+
+    /**
+     * @notice Retrieve whether of the caller is allowed to call a functions for a project
+     * @param _contract The contract address.
+     * @param _caller The caller address.
+     * @return isApproved The approval status.
+     */
+    function getContractArtistApproval(
+        address _contract,
+        address _caller
+    ) external view returns (bool);
+
+    /**
+     * @notice Allowed caller can to set a contract function caller.
+     * @param _contract The contract address.
+     * @param _selector The function selector.
+     * @param _caller The caller address.
+     * @dev this function is gated to only superAdmin address or allowed caller.
+     */
+    function toggleContractSelectorApproval(
+        address _contract,
+        bytes4 _selector,
+        address _caller
+    ) external;
+
+    /**
+     * @notice Toggles verification for artists to call functions relating to their projects on a contract
+     * @param _contract The contract address.
+     * @param _caller The caller address.
+     * @dev this function is gated to only allwed addressed.
+     */
+    function toggleContractArtistApproval(
+        address _contract,
+        address _caller
+    ) external;
+
+    /**
+     * @notice Checks if sender `_sender` is allowed to call function (or functions for projects) with
+     * method `_selector` on `_contract`. Returns true if sender is superAdmin.
+     * @param _sender The sender address.
+     * @param _contract The contract address.
+     * @param _selector The function selector.
+     * @param _projectId The project ID.
+     * @return isApproved The approval status.
+     * @dev this function is public insteaad of internal so that the right to toggle approvals can also be delegated
+     */
+    function allowed(
+        address _sender,
+        address _contract,
+        bytes4 _selector,
+        uint256 _projectId
+    ) external returns (bool);
+
+    /**
+     * @notice Hash the contract address, selector, and caller address.
+     * @param _contract The contract address.
+     * @param _selector The function selector.
+     * @param _caller The caller address.
+     * @return hash The hash.
+     */
+    function hashSelectorApprovalKey(
+        address _contract,
+        bytes4 _selector,
+        address _caller
+    ) external pure returns (bytes32);
+
+    /**
+     * @notice Hash the contract address and artist address.
+     * @param _contract The contract address.
+     * @param _caller The artist address.
+     * @return hash The hash.
+     */
+    function hashArtistApprovalKey(
+        address _contract,
+        address _caller
+    ) external pure returns (bytes32);
+}

package/contracts/engine/V3/forks/PROHIBITION/interfaces/IGenArt721CoreContractV3_Engine_Flex_PROHIBITION.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import "./IAdminACLV0_PROHIBITION.sol";
+import "../../../../../interfaces/v0.8.x/IGenArt721CoreContractV3_Engine_Flex.sol";
+
+/**
+ * @title This interface is intended to house interface items that are common
+ * across all GenArt721CoreContractV3 Engine Flex and derivative implementations.
+ * @author Art Blocks Inc.
+ */
+interface IGenArt721CoreContractV3_Engine_Flex_PROHIBITION is
+    IGenArt721CoreContractV3_Engine_Flex
+{
+    /**
+     * Function determining if _sender is allowed to call function with
+     * selector _selector on contract `_contract` for project `_projectId`.
+     * Intended to be used with peripheral contracts such as minters, as well
+     * as internally by the core contract itself.
+     */
+    function adminACLAllowed(
+        address _sender,
+        address _contract,
+        bytes4 _selector,
+        uint256 _projectId
+    ) external returns (bool);
+}

package/contracts/engine-registry/CoreRegistryV1.sol

@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.19;
+
+import "../interfaces/v0.8.x/ICoreRegistryV1.sol";
+import "@openzeppelin-4.7/contracts/access/Ownable.sol";
+import "@openzeppelin-4.7/contracts/utils/structs/EnumerableSet.sol";
+
+/**
+ * @title Art Blocks Core Contract Registry, V1.
+ * @author Art Blocks Inc.
+ * @notice Privileged Roles and Ownership:
+ * This contract has a single owner, and is intended to be deployed with a
+ * permissioned owner that has elevated privileges on this contract.
+ * If in the future multiple deployer addresses are needed to interact with
+ * this registry, a new registry version with more complex logic should be
+ * implemented and deployed to replace this.
+ *
+ * This contract builds on the EngineRegistryV0 contract, but encompases more
+ * than just Engine contracts. It is updated to be named CoreRegistry, and is
+ * V1 because it is the next iteration of the V0 Engine Registry.
+ *
+ * This contract is intended to be able to act as a registry of all core
+ * contracts that are allowed to interact with a specific MinterFilter V2.
+ * This includes, but is not limited to:
+ * - Flagship contracts
+ * - Collaboration contracts
+ * - Engine contracts
+ * - Engine Flex contracts
+ *
+ * Note that not all contracts will be registered in this registry, as some
+ * contracts may not need to interact with a MinterFilterV2 contract. For
+ * example, the original Art Blocks V0 contract does not need to interact with
+ * a MinterFilterV2 contract, as it uses a different minting mechanism.
+ *
+ * A view function is provided to determine if a contract is registered.
+ *
+ * This contract is designed to be managed by an owner with privileged roles
+ * and abilities.
+ * ----------------------------------------------------------------------------
+ * The following function is restricted to the engine registry owner sending,
+ * or the core contract being registered during a transaction originating from
+ * the engine registry owner:
+ * - registerContract
+ * ----------------------------------------------------------------------------
+ * The following functions are restricted to the engine registry owner sending:
+ * - unregisterContract
+ * - registerContracts
+ * - unregisterContracts
+ * - Ownable: transferOwnership
+ * - Ownable: renounceOwnership
+ * ----------------------------------------------------------------------------
+ * Additional privileged roles may be described on minters, registries, and
+ * other contracts that may interact with this contract.
+ */
+contract CoreRegistryV1 is Ownable, ICoreRegistryV1 {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    /// private enumerable set of registered contracts
+    EnumerableSet.AddressSet private registeredContracts;
+
+    /// private mapping of registered contract addresses to
+    EnumerableSet.AddressSet
+        private registeredMinterFilterV2CompatibleContracts;
+
+    /**
+     * @notice Reverts if `tx.origin` is not the owner.
+     * @dev Warning that this check is only against tx.origin, which may be
+     * misleading when used for security.
+     */
+    function _onlyOwnerOrigin() internal view {
+        require(tx.origin == owner(), "Only tx origin of owner");
+    }
+
+    constructor() Ownable() {}
+
+    /**
+     * @notice Register a contract and emit a `ContractRegistered` event with
+     * the provided information. Only callable by the owner or the contract
+     * being registered, and only if tx.origin == owner.
+     * Reverts if authorization fails, or if the contract is already
+     * registered.
+     */
+    function registerContract(
+        address _contractAddress,
+        bytes32 _coreVersion,
+        bytes32 _coreType
+    ) external {
+        // CHECKS
+        // Validate against `tx.origin` rather than `msg.sender` as it is
+        // intended that this registration be performed in an automated
+        // fashion at the time of contract deployment of `_contractAddress`.
+        // @dev Security implications of using `tx.origin` are acknowledged
+        _onlyOwnerOrigin();
+        // only allow registration of a contract registering itself, or allow
+        // the owner to register any contract.
+        require(
+            msg.sender == _contractAddress || msg.sender == owner(),
+            "Only owner or registrant"
+        );
+        // EFFECTS
+        _registerContract(_contractAddress, _coreVersion, _coreType);
+    }
+
+    /**
+     * @notice Unregister a contract and emit a `ContractUnregistered` event.
+     * Only callable by the owner of this registry contract.
+     * Reverts if authorization fails, or if the contract is not already
+     * registered.
+     */
+    function unregisterContract(address _contractAddress) external {
+        // CHECKS
+        // revert if not called by owner
+        Ownable._checkOwner();
+        // EFFECTS
+        _unregisterContract(_contractAddress);
+    }
+
+    /**
+     * @notice Register multiple contracts at once.
+     * Only callable by the owner.
+     * Reverts if any contract is already registered.
+     * @dev This should primarily be used for backfilling the registry with
+     * existing contracts shortly after deployment.
+     * @param _contractAddresses Array of contract addresses to register.
+     * @param _coreVersions Array of core versions for each contract (aligned).
+     * @param _coreTypes Array of core types for each contract (aligned).
+     */
+    function registerContracts(
+        address[] calldata _contractAddresses,
+        bytes32[] calldata _coreVersions,
+        bytes32[] calldata _coreTypes
+    ) external {
+        // CHECKS
+        // revert if not called by owner
+        Ownable._checkOwner();
+        // validate same length arrays
+        uint256 numContracts = _contractAddresses.length;
+        require(
+            numContracts == _coreVersions.length &&
+                numContracts == _coreTypes.length,
+            "Mismatched array lengths"
+        );
+        // EFFECTS
+        for (uint256 i = 0; i < numContracts; ) {
+            _registerContract(
+                _contractAddresses[i],
+                _coreVersions[i],
+                _coreTypes[i]
+            );
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /**
+     * @notice Unregister multiple contracts at once.
+     * Only callable by the owner.
+     * Reverts if any contract is not already registered.
+     * @param _contractAddresses Array of contract addresses to unregister.
+     */
+    function unregisterContracts(
+        address[] calldata _contractAddresses
+    ) external {
+        // CHECKS
+        // revert if not called by owner
+        Ownable._checkOwner();
+        // EFFECTS
+        uint256 numContracts = _contractAddresses.length;
+        for (uint256 i = 0; i < numContracts; ) {
+            _unregisterContract(_contractAddresses[i]);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /**
+     * @notice Get the number of registered contracts.
+     * @return The number of registered contracts.
+     */
+    function getNumRegisteredContracts() external view returns (uint256) {
+        return registeredContracts.length();
+    }
+
+    /**
+     * @notice Get the address of a registered contract by index.
+     * @param _index The index of the contract to get.
+     * @return The address of the contract at the given index.
+     */
+    function getRegisteredContractAt(
+        uint256 _index
+    ) external view returns (address) {
+        return registeredContracts.at(_index);
+    }
+
+    /**
+     * @notice Gets an array of all registered contract addresses.
+     * Warning: Unbounded gas limit. This function is gas intensive and should
+     * only be used for off-chain analysis. Please use
+     * `getNumRegisteredContracts` and `getRegisteredContractAt` for bounded
+     * gas usage.
+     */
+    function getAllRegisteredContracts()
+        external
+        view
+        returns (address[] memory)
+    {
+        return registeredContracts.values();
+    }
+
+    /**
+     * @notice Returns boolean representing if contract is registered on this
+     * registry.
+     * @param _contractAddress The address of the contract to check.
+     * @return isRegistered True if the contract is registered.
+     */
+    function isRegisteredContract(
+        address _contractAddress
+    ) external view returns (bool isRegistered) {
+        return registeredContracts.contains(_contractAddress);
+    }
+
+    /**
+     * @notice Internal function to register a contract.
+     * Reverts if the contract is already registered.
+     */
+    function _registerContract(
+        address _contractAddress,
+        bytes32 _coreVersion,
+        bytes32 _coreType
+    ) internal {
+        // @dev add returns true only if not already registered
+        require(
+            registeredContracts.add(_contractAddress),
+            "Contract already registered"
+        );
+        emit ContractRegistered(_contractAddress, _coreVersion, _coreType);
+    }
+
+    /**
+     * @notice Internal function to unregister a contract.
+     * Reverts if the contract is not already registered.
+     */
+    function _unregisterContract(address _contractAddress) internal {
+        // @dev remove returns true only if already in set
+        require(
+            registeredContracts.remove(_contractAddress),
+            "Only registered contracts"
+        );
+        emit ContractUnregistered(_contractAddress);
+    }
+}

package/contracts/engine-registry/EngineRegistryV0.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
-import "../interfaces/0.8.x/IEngineRegistryV0.sol";
+import "../interfaces/v0.8.x/IEngineRegistryV0.sol";
 import "@openzeppelin-4.7/contracts/utils/introspection/ERC165.sol";
 
 /**

package/contracts/explorations/GenArt721CoreV3_Explorations.sol

@@ -1,18 +1,19 @@
 // SPDX-License-Identifier: LGPL-3.0-only
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 // Created By: Art Blocks Inc.
 
-import "../interfaces/0.8.x/IRandomizerV2.sol";
-import "../interfaces/0.8.x/IAdminACLV0.sol";
-import "../interfaces/0.8.x/IGenArt721CoreContractV3.sol";
-import "../interfaces/0.8.x/IManifold.sol";
+import "../interfaces/v0.8.x/IRandomizerV2.sol";
+import "../interfaces/v0.8.x/IAdminACLV0.sol";
+import "../interfaces/v0.8.x/IGenArt721CoreContractV3.sol";
+import "../interfaces/v0.8.x/IGenArt721CoreContractExposesHashSeed.sol";
+import "../interfaces/v0.8.x/IManifold.sol";
 
 import "@openzeppelin-4.7/contracts/utils/Strings.sol";
 import "@openzeppelin-4.7/contracts/access/Ownable.sol";
-import "../libs/0.8.x/ERC721_PackedHashSeed.sol";
-import "../libs/0.8.x/BytecodeStorage.sol";
-import "../libs/0.8.x/Bytes32Strings.sol";
+import "../libs/v0.8.x/ERC721_PackedHashSeed.sol";
+import "../libs/v0.8.x/BytecodeStorageV1.sol";
+import "../libs/v0.8.x/Bytes32Strings.sol";
 
 /**
  * @title Art Blocks ERC-721 core contract, V3_Explorations.
@@ -88,10 +89,10 @@ import "../libs/0.8.x/Bytes32Strings.sol";
 contract GenArt721CoreV3_Explorations is
     ERC721_PackedHashSeed,
     Ownable,
-    IGenArt721CoreContractV3
+    IGenArt721CoreContractV3,
+    IGenArt721CoreContractExposesHashSeed
 {
-    using BytecodeStorage for string;
-    using BytecodeStorage for address;
+    using BytecodeStorageWriter for string;
     using Bytes32Strings for bytes32;
     using Strings for uint256;
     using Strings for address;
@@ -180,7 +181,7 @@ contract GenArt721CoreV3_Explorations is
         bool paused;
         string name;
         string artist;
-        string description;
+        address descriptionAddress;
         string website;
         string license;
         string projectBaseURI;
@@ -237,7 +238,7 @@ contract GenArt721CoreV3_Explorations is
     /// version & type of this core contract
     /// coreVersion is updated from Flagship V3 core due to minor changes
     /// implemented in the Explorations version of the contract.
-    string public constant coreVersion = "v3.0.3";
+    string public constant coreVersion = "v3.2.3";
     /// coreType remains consistent with flagship V3 core because external &
     /// public functions used for indexing are unchanged.
     string public constant coreType = "GenArt721CoreV3";
@@ -949,6 +950,13 @@ contract GenArt721CoreV3_Explorations is
     /**
      * @notice Updates description of project `_projectId`.
      * Only artist may call when unlocked, only admin may call when locked.
+     * Note: The BytecodeStorage library is used to store the description to
+     * reduce initial upload cost, however, even minor edits will require an
+     * expensive, entirely new bytecode storage contract to be deployed instead
+     * of relatively cheap updates to already-warm storage slots. This results
+     * in an increased gas cost for minor edits to the description after the
+     * initial upload, but an overall decrease in gas cost for projects with
+     * less than ~3-5 edits (depending on the length of the description).
      * @param _projectId Project ID.
      * @param _projectDescription New project description.
      */
@@ -968,7 +976,10 @@ contract GenArt721CoreV3_Explorations is
             "Only artist when unlocked, owner when locked"
         );
         // effects
-        projects[_projectId].description = _projectDescription;
+        // store description in contract bytecode, replacing reference address from
+        // the old storage description with the newly created one
+        projects[_projectId].descriptionAddress = _projectDescription
+            .writeToBytecode();
         emit ProjectUpdated(_projectId, FIELD_PROJECT_DESCRIPTION);
     }
 
@@ -1076,18 +1087,8 @@ contract GenArt721CoreV3_Explorations is
         _onlyNonEmptyString(_script);
         Project storage project = projects[_projectId];
         require(_scriptId < project.scriptCount, "scriptId out of range");
-        // purge old contract bytecode contract from the blockchain state
-        // note: Although this does reduce usage of Ethereum state, it does not
-        // reduce the gas costs of removal transactions. We believe this is the
-        // best behavior at the time of writing, and do not expect this to
-        // result in any breaking changes in the future. All current proposals
-        // to change the self-destruct opcode are backwards compatible, but may
-        // result in not removing the bytecode from the blockchain state. This
-        // implementation is compatible with that architecture, as it does not
-        // rely on the bytecode being removed from the blockchain state.
-        project.scriptBytecodeAddresses[_scriptId].purgeBytecode();
         // store script in contract bytecode, replacing reference address from
-        // the contract that no longer exists with the newly created one
+        // the old storage contract with the newly created one
         project.scriptBytecodeAddresses[_scriptId] = _script.writeToBytecode();
         emit ProjectUpdated(_projectId, FIELD_PROJECT_SCRIPT);
     }
@@ -1104,19 +1105,7 @@ contract GenArt721CoreV3_Explorations is
         );
         Project storage project = projects[_projectId];
         require(project.scriptCount > 0, "there are no scripts to remove");
-        // purge old contract bytecode contract from the blockchain state
-        // note: Although this does reduce usage of Ethereum state, it does not
-        // reduce the gas costs of removal transactions. We believe this is the
-        // best behavior at the time of writing, and do not expect this to
-        // result in any breaking changes in the future. All current proposals
-        // to change the self-destruct opcode are backwards compatible, but may
-        // result in not removing the bytecode from the blockchain state. This
-        // implementation is compatible with that architecture, as it does not
-        // rely on the bytecode being removed from the blockchain state.
-        project
-            .scriptBytecodeAddresses[project.scriptCount - 1]
-            .purgeBytecode();
-        // delete reference to contract address that no longer exists
+        // delete reference to old storage contract address
         delete project.scriptBytecodeAddresses[project.scriptCount - 1];
         unchecked {
             project.scriptCount = project.scriptCount - 1;
@@ -1253,6 +1242,20 @@ contract GenArt721CoreV3_Explorations is
         return keccak256(abi.encode(_hashSeed));
     }
 
+    /**
+     * @notice Returns token hash **seed** for token ID `_tokenId`. Returns
+     * null if hash seed has not been set. The hash seed id the bytes12 value
+     * which is hashed to produce the token hash.
+     * @param _tokenId Token ID to be queried.
+     * @return bytes12 Token hash seed.
+     * @dev token hash seed is keccak256 hashed to give the token hash
+     */
+    function tokenIdToHashSeed(
+        uint256 _tokenId
+    ) external view returns (bytes12) {
+        return _ownersAndHashSeeds[_tokenId].hashSeed;
+    }
+
     /**
      * @notice View function returning Art Blocks portion of primary sales, in
      * percent.
@@ -1367,7 +1370,12 @@ contract GenArt721CoreV3_Explorations is
         Project storage project = projects[_projectId];
         projectName = project.name;
         artist = project.artist;
-        description = project.description;
+        address projectDescriptionBytecodeAddress = project.descriptionAddress;
+        if (projectDescriptionBytecodeAddress == address(0)) {
+            description = "";
+        } else {
+            description = _readFromBytecode(projectDescriptionBytecodeAddress);
+        }
         website = project.website;
         license = project.license;
     }
@@ -1505,7 +1513,7 @@ contract GenArt721CoreV3_Explorations is
         if (_index >= project.scriptCount) {
             return "";
         }
-        return project.scriptBytecodeAddresses[_index].readFromBytecode();
+        return _readFromBytecode(project.scriptBytecodeAddresses[_index]);
     }
 
     /**
@@ -1957,4 +1965,14 @@ contract GenArt721CoreV3_Explorations is
             (block.timestamp - projectCompletedTimestamp <
                 FOUR_WEEKS_IN_SECONDS);
     }
+
+    /**
+     * Helper for calling `BytecodeStorageReader` external library reader method,
+     * added for bytecode size reduction purposes.
+     */
+    function _readFromBytecode(
+        address _address
+    ) internal view returns (string memory) {
+        return BytecodeStorageReader.readFromBytecode(_address);
+    }
 }

package/contracts/interfaces/v0.8.x/IBytecodeStorageReader.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Art Blocks Script Storage Library (Reader)
+ * @notice This interface defines the expected read functions for the Art Blocks Script Storage Library (Reader).
+ */
+interface IBytecodeStorageReader {
+    /**
+     * @notice Read a string from contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @return data string read from contract bytecode
+     * @dev This function performs input validation that the contract to read is in an expected format
+     */
+    function readFromBytecode(
+        address _address
+    ) external view returns (string memory data);
+
+    /**
+     * @notice Read the bytes from contract bytecode that was written to the EVM using SSTORE2
+     * @param _address address of deployed contract with bytecode stored in the SSTORE2 format
+     * @return data bytes read from contract bytecode
+     * @dev This function performs no input validation on the provided contract,
+     *      other than that there is content to read (but not that its a "storage contract")
+     */
+    function readBytesFromSSTORE2Bytecode(
+        address _address
+    ) external view returns (bytes memory data);
+
+    /**
+     * @notice Read the bytes from contract bytecode, with an explicitly provided starting offset
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @param _offset offset to read from in contract bytecode, explicitly provided (not calculated)
+     * @return data bytes read from contract bytecode
+     * @dev This function performs no input validation on the provided contract,
+     *      other than that there is content to read (but not that its a "storage contract")
+     */
+    function readBytesFromBytecode(
+        address _address,
+        uint256 _offset
+    ) external view returns (bytes memory data);
+
+    /**
+     * @notice Get address for deployer for given contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @return writerAddress address read from contract bytecode
+     */
+    function getWriterAddressForBytecode(
+        address _address
+    ) external view returns (address);
+
+    /**
+     * @notice Get version for given contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @return version version read from contract bytecode
+     */
+    function getLibraryVersionForBytecode(
+        address _address
+    ) external view returns (bytes32);
+}