@artblocks/contracts 1.3.2 → 1.4.0

package/contracts/minter-suite/Minters/one-off/SeaDropXArtBlocksShim.sol

@@ -416,23 +416,33 @@ contract SeaDropXArtBlocksShim is
     // --- external functions from ISeaDropTokenContractMetadata ---
 
     /**
-     * @notice Sets the base URI for the token metadata and emits an event.
-     * Reverts - baseURI must be configured on the Art Blocks core contract.
+     * @notice Sets the base URI for the token metadata.
+     * Warning - baseURI is a no-op on this shim contract, and the baseURI must be configured
+     * on the Art Blocks core contract. This function is included for compatibility with the
+     * SeaDropTokenContractMetadata interface to prevent unnecessary reverts. No-op is preferred
+     * over reverting.
      */
-    function setBaseURI(string calldata /*tokenURI*/) external pure {
-        revert(
-            "SeaDropXArtBlocksShim: baseURI must be configured on the Art Blocks core contract"
-        );
+    function setBaseURI(string calldata /*tokenURI*/) external view {
+        // CHECKS
+        _onlyArtistOrSelf(msg.sender);
+
+        // EFFECTS
+        // no-op
     }
 
     /**
      * @notice Sets the contract URI for contract metadata.
-     * Reverts - contractURI is not supported on the Art Blocks core contract.
+     * Warning - contractURI is a no-op on this shim contract, and the contractURI must be configured
+     * on the Art Blocks core contract. This function is included for compatibility with the
+     * SeaDropTokenContractMetadata interface to prevent unnecessary reverts. No-op is preferred
+     * over reverting.
      */
-    function setContractURI(string calldata /*newContractURI*/) external pure {
-        revert(
-            "SeaDropXArtBlocksShim: contractURI not supported on the Art Blocks core contract"
-        );
+    function setContractURI(string calldata /*newContractURI*/) external view {
+        // CHECKS
+        _onlyArtistOrSelf(msg.sender);
+
+        // EFFECTS
+        // no-op
     }
 
     /**
@@ -449,9 +459,15 @@ contract SeaDropXArtBlocksShim is
         _onlyArtistOrSelf(msg.sender);
 
         // ensure maxSupply lte project's max invocations on core contract
-        (, uint256 maxInvocations) = _getInvocationsDataFromCore();
-        if (newMaxSupply > maxInvocations) {
-            revert(
+        (
+            ,
+            uint256 maxInvocationsOnCoreContract
+        ) = _getInvocationsDataFromCore();
+        if (newMaxSupply > maxInvocationsOnCoreContract) {
+            // @dev revert if not special case of OpenSea OpenEdition (200M) and Art Blocks OpenEdition (1M)
+            require(
+                newMaxSupply == 200_000_000 &&
+                    maxInvocationsOnCoreContract == 1_000_000,
                 "SeaDropXArtBlocksShim: Only newMaxSupply lte max invocations on the Art Blocks core contract"
             );
         }
@@ -459,27 +475,37 @@ contract SeaDropXArtBlocksShim is
         // EFFECTS
         // set the local max supply
         localMaxSupply = newMaxSupply;
-        emit LocalMaxSupplyUpdated(newMaxSupply);
+        emit MaxSupplyUpdated(newMaxSupply);
     }
 
     /**
-     * @notice Sets the provenance hash and emits an event.
-     * Reverts - provenanceHash is not supported on the Art Blocks core contract.
+     * @notice Sets the provenance hash.
+     * Warning - provenanceHash is a no-op on this shim contract, and the provenanceHash is not supported
+     * on the Art Blocks core contract. This function is included for compatibility with the
+     * SeaDropTokenContractMetadata interface to prevent unnecessary reverts. No-op is preferred
+     * over reverting.
      */
-    function setProvenanceHash(bytes32 /*newProvenanceHash*/) external pure {
-        revert(
-            "SeaDropXArtBlocksShim: provenance hash not supported on Art Blocks contracts"
-        );
+    function setProvenanceHash(bytes32 /*newProvenanceHash*/) external view {
+        // CHECKS
+        _onlyArtistOrSelf(msg.sender);
+
+        // EFFECTS
+        // no-op
     }
 
     /**
      * @notice Sets the address and basis points for royalties.
-     * Reverts - royalties must be configured on the Art Blocks core contract.
+     * Warning - royalties are a no-op on this shim contract, and the royalties must be configured
+     * on the Art Blocks core contract. This function is included for compatibility with the
+     * SeaDropTokenContractMetadata interface to prevent unnecessary reverts. No-op is preferred
+     * over reverting.
      */
-    function setRoyaltyInfo(RoyaltyInfo calldata /*newInfo*/) external pure {
-        revert(
-            "SeaDropXArtBlocksShim: royalties must be configured on the Art Blocks core contract"
-        );
+    function setRoyaltyInfo(RoyaltyInfo calldata /*newInfo*/) external view {
+        // CHECKS
+        _onlyArtistOrSelf(msg.sender);
+
+        // EFFECTS
+        // no-op
     }
 
     // --- external functions from https://github.com/ProjectOpenSea/seadrop/blob/main/src/ERC721SeaDrop.sol ---
@@ -488,13 +514,8 @@ contract SeaDropXArtBlocksShim is
      * @notice Configure multiple properties at a time.
      * Note: The individual configure methods should be used to unset or reset any properties to zero, as this method
      * will ignore zero-value properties in the config struct.
-     * The following parameters are not supported in this function, will cause revert, and should be configured on the
-     * Art Blocks core contract directly:
-     * - maxSupply
+     * The following parameters are not supported in this function, and will be ignored/no-op:
      * - baseURI
-     * - allowedFeeRecipients
-     * - disallowedFeeRecipients
-     * The following parameters are not supported by Art Blocks contracts and will cause revert:
      * - contractURI
      * - provenanceHash
      * @dev logic for supported operations is taken from example SeaDrop implementation, and was tested end-to-end, and
@@ -510,14 +531,12 @@ contract SeaDropXArtBlocksShim is
             this.setMaxSupply(config.maxSupply);
         }
         if (bytes(config.baseURI).length != 0) {
-            revert(
-                "SeaDropXArtBlocksShim: baseURI must be configured on the Art Blocks core contract"
-            );
+            // @dev this is a no-op on this shim contract
+            this.setBaseURI(config.baseURI);
         }
         if (bytes(config.contractURI).length != 0) {
-            revert(
-                "SeaDropXArtBlocksShim: contractURI not supported on the Art Blocks core contract"
-            );
+            // @dev this is a no-op on this shim contract
+            this.setContractURI(config.contractURI);
         }
         if (
             config.publicDrop.startTime != 0 || config.publicDrop.endTime != 0
@@ -537,9 +556,8 @@ contract SeaDropXArtBlocksShim is
             );
         }
         if (config.provenanceHash != bytes32(0)) {
-            revert(
-                "SeaDropXArtBlocksShim: provenance hash not supported on Art Blocks contracts"
-            );
+            // @dev this is a no-op on this shim contract
+            this.setProvenanceHash(config.provenanceHash);
         }
         if (config.allowedFeeRecipients.length > 0) {
             for (uint256 i = 0; i < config.allowedFeeRecipients.length; ) {

package/contracts/mock/ENSLibMock.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity 0.8.22;
+
+import {ENSLib} from "../libs/v0.8.x/ENSLib.sol";
+
+/**
+ * @title ENSLibMock
+ * @notice Mock contract to expose ENSLib functions for testing
+ * @dev This contract is only used for testing and should not be deployed in production
+ * @author Art Blocks Inc.
+ */
+contract ENSLibMock {
+    /**
+     * @notice Wrapper for ENSLib.getEnsName to enable testing
+     * @param ownerAddress The address to resolve the ENS name for
+     * @return The ENS name for the address, or empty string if not found/invalid
+     */
+    function getEnsName(
+        address ownerAddress
+    ) external view returns (string memory) {
+        return ENSLib.getEnsName(ownerAddress);
+    }
+}

package/contracts/mock/EnumerableSetUint16Mock.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import {EnumerableSetUint16} from "../libs/v0.8.x/EnumerableSetUint16.sol";
+
+/**
+ * @title EnumerableSetUint16Mock
+ * @author Art Blocks Inc.
+ * @notice Mock contract for testing EnumerableSetUint16 library
+ */
+contract EnumerableSetUint16Mock {
+    using EnumerableSetUint16 for EnumerableSetUint16.Uint16Set;
+
+    EnumerableSetUint16.Uint16Set private _set;
+
+    /**
+     * @dev Add a value to the set. Returns true if added, false if already present.
+     */
+    function add(uint16 value) external returns (bool) {
+        return _set.add(value);
+    }
+
+    /**
+     * @dev Remove a value from the set. Returns true if removed, false if not present.
+     */
+    function remove(uint16 value) external returns (bool) {
+        return _set.remove(value);
+    }
+
+    /**
+     * @dev Check if a value is in the set.
+     */
+    function contains(uint16 value) external view returns (bool) {
+        return _set.contains(value);
+    }
+
+    /**
+     * @dev Get the number of values in the set.
+     */
+    function length() external view returns (uint256) {
+        return _set.length();
+    }
+
+    /**
+     * @dev Get the value at a specific index.
+     */
+    function at(uint256 index) external view returns (uint16) {
+        return _set.at(index);
+    }
+
+    /**
+     * @dev Get all values in the set.
+     */
+    function values() external view returns (uint256[] memory) {
+        return _set.values();
+    }
+
+    /**
+     * @dev Add multiple values at once for testing.
+     */
+    function addMultiple(uint16[] calldata valuesToAdd) external {
+        for (uint256 i = 0; i < valuesToAdd.length; i++) {
+            _set.add(valuesToAdd[i]);
+        }
+    }
+
+    /**
+     * @dev Remove multiple values at once for testing.
+     */
+    function removeMultiple(uint16[] calldata valuesToRemove) external {
+        for (uint256 i = 0; i < valuesToRemove.length; i++) {
+            _set.remove(valuesToRemove[i]);
+        }
+    }
+
+    /**
+     * @dev Clear all values from the set.
+     */
+    function clear() external {
+        uint256 len = _set.length();
+        for (uint256 i = 0; i < len; i++) {
+            uint16 value = _set.at(0);
+            _set.remove(value);
+        }
+    }
+}

package/contracts/mock/FeistelWalkLibMock.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {FeistelWalkLib} from "../libs/v0.8.x/FeistelWalkLib.sol";
+
+/**
+ * @title FeistelWalkLibMock
+ * @notice Mock contract for testing FeistelWalkLib library functionality
+ */
+contract FeistelWalkLibMock {
+    using FeistelWalkLib for FeistelWalkLib.Plan;
+
+    /**
+     * @notice Build a Feistel permutation plan
+     * @param seed Arbitrary seed
+     * @param N Domain size
+     * @return N The domain size
+     * @return M The next power of two >= N
+     * @return logM The log2 of M (precomputed)
+     * @return rounds The number of Feistel rounds (always 2)
+     * @return k0 First round key
+     * @return k1 Second round key
+     */
+    function makePlan(
+        bytes32 seed,
+        uint256 N
+    )
+        external
+        pure
+        returns (uint256, uint256, uint256, uint256, uint64, uint64)
+    {
+        FeistelWalkLib.Plan memory p = FeistelWalkLib.makePlan(seed, N);
+        return (p.N, p.M, p.logM, p.rounds, p.k0, p.k1);
+    }
+
+    /**
+     * @notice Get the k-th index in the permutation
+     * @param seed Arbitrary seed
+     * @param N Domain size
+     * @param k The index in the permutation sequence
+     * @return The permuted index
+     */
+    function index(
+        bytes32 seed,
+        uint256 N,
+        uint256 k
+    ) external pure returns (uint256) {
+        FeistelWalkLib.Plan memory p = FeistelWalkLib.makePlan(seed, N);
+        return FeistelWalkLib.index(p, k);
+    }
+
+    /**
+     * @notice Sample K indices from the permutation
+     * @param seed Arbitrary seed
+     * @param N Domain size
+     * @param K Number of samples to take
+     * @return Array of K permuted indices
+     */
+    function sample(
+        bytes32 seed,
+        uint256 N,
+        uint256 K
+    ) external pure returns (uint256[] memory) {
+        FeistelWalkLib.Plan memory p = FeistelWalkLib.makePlan(seed, N);
+        return FeistelWalkLib.sample(p, K);
+    }
+
+    /**
+     * @notice Get all N indices in the permutation (full traversal)
+     * @param seed Arbitrary seed
+     * @param N Domain size
+     * @return Array of all N permuted indices
+     */
+    function fullTraversal(
+        bytes32 seed,
+        uint256 N
+    ) external pure returns (uint256[] memory) {
+        FeistelWalkLib.Plan memory p = FeistelWalkLib.makePlan(seed, N);
+        return FeistelWalkLib.sample(p, N);
+    }
+}

package/contracts/mock/ImmutableUint16ArrayMock.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {ImmutableUint16Array} from "../libs/v0.8.x/ImmutableUint16Array.sol";
+
+/**
+ * @title ImmutableUint16ArrayMock
+ * @notice Mock contract for testing ImmutableUint16Array library functionality
+ */
+contract ImmutableUint16ArrayMock {
+    using ImmutableUint16Array for ImmutableUint16Array.Uint16Array;
+
+    ImmutableUint16Array.Uint16Array private uint16Array;
+
+    /**
+     * @notice Store an array of uint16 values
+     * @param values The array of uint16 values to store
+     */
+    function store(uint16[] memory values) external {
+        uint16Array.store(values);
+    }
+
+    /**
+     * @notice Clear the stored array
+     */
+    function clear() external {
+        uint16Array.clear();
+    }
+
+    /**
+     * @notice Check if the array is empty
+     * @return Whether the array is empty
+     */
+    function isEmpty() external view returns (bool) {
+        return uint16Array.isEmpty();
+    }
+
+    /**
+     * @notice Get the length of the stored array
+     * @return The number of uint16 values stored
+     */
+    function length() external view returns (uint256) {
+        return uint16Array.length();
+    }
+
+    /**
+     * @notice Get a uint16 value at a specific index
+     * @param index The index to retrieve
+     * @return The uint16 value at the given index
+     */
+    function get(uint256 index) external view returns (uint16) {
+        return uint16Array.get(index);
+    }
+
+    /**
+     * @notice Get all stored uint16 values
+     * @return An array containing all stored uint16 values
+     */
+    function getAll() external view returns (uint16[] memory) {
+        return uint16Array.getAll();
+    }
+}