@artblocks/contracts 1.3.2 → 1.4.0

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

@@ -10,10 +10,4 @@ interface ISeaDropShimForContract {
      * @param nftContract The address of the NFT contract that this shim contract is compatible with
      */
     event SeaDropShimForContract(address nftContract);
-
-    /**
-     * @dev Emit event when the local max supply is updated
-     * @param newLocalMaxSupply The new local max supply
-     */
-    event LocalMaxSupplyUpdated(uint256 newLocalMaxSupply);
 }

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

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title This interface adds support for tiered allowlist pricing.
+ * @notice Intended for shared minters that expose both a public price and a
+ * privileged allowlist price, and that can resolve the effective price for a
+ * given wallet.
+ * @author Art Blocks Inc.
+ */
+interface ISharedMinterTieredAllowV0 {
+    /**
+     * @notice Gets if price is configured, allowlist price of minting a token
+     * on project `projectId`, and currency symbol and address to be used as
+     * payment.
+     * @param projectId Project ID to get allowlist price information for
+     * @param coreContract Contract address of the core contract
+     * @return isConfigured true only if prices have been configured on this
+     * minter
+     * @return tokenPriceInWei current allowlist price of token on this minter
+     * @return currencySymbol currency symbol for purchases of project on this
+     * minter
+     * @return currencyAddress currency address for purchases of project on
+     * this minter
+     */
+    function getAllowlistPriceInfo(
+        uint256 projectId,
+        address coreContract
+    )
+        external
+        view
+        returns (
+            bool isConfigured,
+            uint256 tokenPriceInWei,
+            string memory currencySymbol,
+            address currencyAddress
+        );
+
+    /**
+     * @notice Returns the effective price for a given wallet address on
+     * project `projectId`. If the wallet is allowlisted, returns the
+     * allowlist price; otherwise returns the public price.
+     * @param projectId Project ID to get price information for
+     * @param coreContract Contract address of the core contract
+     * @param wallet Address to check the effective price for
+     * @return isConfigured true only if prices have been configured for the
+     * project
+     * @return tokenPriceInWei effective price per token for the given wallet
+     * @return currencySymbol currency symbol for purchases of project on this
+     * minter
+     * @return currencyAddress currency address for purchases of project on
+     * this minter
+     */
+    function getPriceInfoForAddress(
+        uint256 projectId,
+        address coreContract,
+        address wallet
+    )
+        external
+        view
+        returns (
+            bool isConfigured,
+            uint256 tokenPriceInWei,
+            string memory currencySymbol,
+            address currencyAddress
+        );
+}

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

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin-5.0/contracts/interfaces/IERC165.sol";
+
+/**
+ * @title Transfer hook interface for Art Blocks V3 Engine cores.
+ * @author Art Blocks Inc.
+ * @notice Invoked by a core after a token's ownership has been updated (mint
+ * or transfer). A reverting hook aborts the entire mint or transfer.
+ * Implementations MUST authenticate `msg.sender` as the expected core; the
+ * core passes `coreContract` for convenience when one hook serves many cores.
+ * Inheriting `AbstractTransferHook` is the recommended way to satisfy both
+ * that requirement and the ERC-165 requirement below.
+ * @dev A core will not accept a hook unless it ERC-165-advertises this
+ * interface. The ERC-165 interface ID is `0x6344b0e2`, which is
+ * `type(ITransferHook).interfaceId` — the selector of `onTokenTransfer`
+ * alone. Solidity excludes inherited interface functions (here, `IERC165`)
+ * from that XOR, so implementers hardcoding the value must use `0x6344b0e2`
+ * and not XOR in `IERC165`'s `0x01ffc9a7`.
+ */
+interface ITransferHook is IERC165 {
+    /**
+     * @notice Execution logic to be executed after a token's ownership updates.
+     * @dev Called after the ERC-721 ownership write. On mint, called after the
+     * token hash seed is assigned. Reverting aborts the mint or transfer.
+     * @dev The calling core blocks reentrant mints and transfers for the
+     * duration of this call, on every project of that core. Implementations
+     * must not attempt to mint or transfer on the calling core.
+     * @param coreContract The core contract that performed the ownership update.
+     * Also equal to `msg.sender` when called by a conforming core.
+     * @param tokenId The token whose ownership changed.
+     * @param from Previous owner. `address(0)` on mint.
+     * @param to New owner. `address(0)` on burn (cores do not currently burn).
+     * @param operator For transfers, the ERC-721 operator (`_msgSender()`).
+     * For mint, the `_by` address passed to `mint_Ecf` (the initiating user,
+     * not the minter contract).
+     */
+    function onTokenTransfer(
+        address coreContract,
+        uint256 tokenId,
+        address from,
+        address to,
+        address operator
+    ) external;
+}

package/contracts/libs/v0.8.x/DependencyRegistryStorageLib.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.19;
 import "../../interfaces/v0.8.x/IAdminACLV0.sol";
 import "../../interfaces/v0.8.x/ICoreRegistryV1.sol";
 import "../../interfaces/v0.8.x/IUniversalBytecodeStorageReader.sol";
+import {IDependencyRegistryV0} from "../../interfaces/v0.8.x/IDependencyRegistryV0.sol";
 import "@openzeppelin-4.7/contracts/utils/structs/EnumerableSet.sol";
 
 /**
@@ -51,6 +52,17 @@ library DependencyRegistryStorageLib {
         uint24 additionalRepositoryCount;
         // count of scripts that make up the dependency, if the dependency is available on-chain
         uint24 scriptCount;
+        // @dev fields below are appended for the generator's rendering directives, and are
+        // safe to append because Dependency is only ever used as a mapping value.
+        // canvas tag requirement for the dependency
+        IDependencyRegistryV0.CanvasTagType canvasTagType;
+        // how a project's script must be injected into generated HTML
+        IDependencyRegistryV0.ProjectScriptTagType projectScriptTagType;
+        // whether the dependency's own script is an ES module, and therefore must be exposed to
+        // project scripts via an import map rather than loaded with a plain `<script src>` tag
+        bool loadAsModule;
+        // `type` attribute used when projectScriptTagType is SpecialType; empty otherwise
+        string projectScriptSpecialType;
     }
 
     /**

package/contracts/libs/v0.8.x/ENSLib.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title IUniversalResolver
+ * @notice Minimal ENS Universal Resolver interface for reverse resolution
+ * @dev See https://docs.ens.domains/resolvers/universal#reverse-resolution
+ */
+interface IUniversalResolver {
+    function reverse(
+        bytes calldata lookupAddress,
+        uint256 coinType
+    )
+        external
+        view
+        returns (
+            string memory primary,
+            address resolver,
+            address reverseResolver
+        );
+}
+
+/**
+ * @title ENS Library
+ * @notice This library provides helper functions for ENS name resolution
+ * using the ENS Universal Resolver following ENS best practices.
+ * @author Art Blocks Inc.
+ * @dev This library uses the Universal Resolver's reverse() function which
+ * performs both reverse lookup AND forward verification in a single call.
+ * For an address to have a valid ENS name returned by this library, the owner
+ * must set up a reverse record (reverse lookup) by calling setName() on the
+ * reverse registrar. This is OPTIONAL and must be done by the address owner
+ * on-chain. If not set, the library returns an empty string.
+ *
+ * References:
+ * - Universal Resolver: https://docs.ens.domains/resolvers/universal
+ * - Reverse Resolution: https://docs.ens.domains/resolvers/universal#reverse-resolution
+ */
+library ENSLib {
+    /// @notice ENS Universal Resolver deployment address (same on mainnet and testnets)
+    /// @dev This is a proxy contract owned by ENS DAO
+    /// See: https://docs.ens.domains/resolvers/universal
+    address internal constant UNIVERSAL_RESOLVER_ADDRESS =
+        0xeEeEEEeE14D718C2B47D9923Deab1335E144EeEe;
+
+    /// @notice Coin type for Ethereum (used in reverse resolution)
+    /// @dev See ENSIP-9 for multichain address resolution
+    uint256 internal constant COIN_TYPE_ETH = 60;
+
+    /**
+     * @notice Resolves an ENS name for a given address using the Universal Resolver.
+     * @dev Uses the ENS Universal Resolver's reverse() function which internally:
+     * 1. Performs reverse lookup to get the name claimed by the address
+     * 2. Verifies forward resolution to ensure the name actually resolves back to the address
+     *
+     * This provides protection against spoofing in a single call.
+     *
+     * NOTE: For an address to have a valid ENS name returned by this function, the owner must:
+     * - Set up a reverse record (reverse lookup) by calling setName() on the reverse registrar
+     * - This is OPTIONAL and must be done by the address owner on-chain
+     * - If not set, this function returns an empty string
+     *
+     * @param ownerAddress The address to resolve the ENS name for.
+     * @return ensName The ENS name for the address, or empty string if not found/invalid.
+     */
+    function getEnsName(
+        address ownerAddress
+    ) internal view returns (string memory) {
+        // Call the Universal Resolver's reverse function
+        // The reverse function internally performs both reverse lookup and forward verification
+        try
+            IUniversalResolver(UNIVERSAL_RESOLVER_ADDRESS).reverse(
+                abi.encodePacked(ownerAddress),
+                COIN_TYPE_ETH
+            )
+        returns (string memory primary, address, address) {
+            return primary;
+        } catch {
+            // If any error occurs (no reverse record, forward mismatch, etc.), return empty string
+            return "";
+        }
+    }
+}

package/contracts/libs/v0.8.x/EnumerableSetUint16.sol

@@ -0,0 +1,429 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title EnumerableSetUint16
+ * @author Art Blocks Inc.
+ * @notice Gas-optimized enumerable set library for uint16 values with assembly optimizations.
+ * @dev This library efficiently packs uint16 values into shared uint256 storage slots,
+ * storing up to 16 uint16 values per slot. This significantly reduces gas costs compared
+ * to OpenZeppelin's EnumerableSet.UintSet which stores each value in its own slot.
+ *
+ * The library maintains:
+ * - A packed array where each uint256 slot contains up to 16 uint16 values (stored as value+1)
+ * - An index mapping for O(1) lookups (maps value -> packed position)
+ *
+ * Values are stored as (value + 1) to distinguish empty slots (0) from actual values.
+ * This means the maximum storable value is 65534 (not 65535).
+ *
+ * Count is derived on-demand by examining the last slot to find the highest populated position.
+ * This eliminates an SSTORE operation on every add/remove, significantly reducing gas costs.
+ *
+ * Assembly is used extensively for:
+ * - Efficient bit manipulation operations
+ * - Optimized storage access patterns
+ * - Reduced memory operations
+ * - Binary search for finding highest offset
+ *
+ * Interface is compatible with OpenZeppelin's EnumerableSet.UintSet, but specifically
+ * for uint16 values.
+ */
+library EnumerableSetUint16 {
+    /**
+     * @dev Structure to hold the set data.
+     *
+     * Storage layout:
+     * - _values: Array of uint256 where each element packs 16 uint16 values (stored as value+1)
+     * - _indexesPacked: Packed mapping where each uint256 contains 16 positions (16 bits each)
+     *
+     * Position encoding: 16 bits per position = (slotIndex << 4) | offsetInSlot + 1
+     * - Bits 0-11: slotIndex (supports up to 4096 slots = 65,536 values)
+     * - Bits 12-15: offsetInSlot (0-15)
+     * - +1 makes it 1-indexed so 0 means "not present"
+     *
+     * Packing in _indexesPacked:
+     * - Key: value >> 4 (bucket index - groups of 16 values)
+     * - Value: uint256 containing 16 packed 16-bit positions
+     * - Position in bucket: value & 0xF (determines which 16-bit segment)
+     */
+    struct Uint16Set {
+        // Array of packed uint256 slots, each containing up to 16 uint16 values (as value+1)
+        uint256[] _values;
+        // Packed mapping: each uint256 holds 16 positions (16 bits each) for 16 consecutive values
+        // Bucket (value>>4) maps to uint256 with 16 positions at (value&0xF)*16 bits
+        mapping(uint16 => uint256) _indexesPacked;
+    }
+
+    /**
+     * @dev Add a value to a set. O(1).
+     * Returns true if the value was added to the set, that is if it was not
+     * already present.
+     * @param value The uint16 value to add. Must be < 65535 (max uint16 - 1).
+     */
+    function add(Uint16Set storage set, uint16 value) internal returns (bool) {
+        require(
+            value < type(uint16).max,
+            "EnumerableSetUint16: value too large"
+        );
+
+        if (contains(set, value)) {
+            return false;
+        }
+
+        uint256 count = length(set);
+        uint256 slotIndex;
+        uint256 offsetInSlot;
+
+        assembly {
+            // slotIndex = count >> 4 (count / 16)
+            slotIndex := shr(4, count)
+            // offsetInSlot = count & 0xF (count % 16)
+            offsetInSlot := and(count, 0xF)
+        }
+
+        // Ensure the slot exists
+        if (slotIndex >= set._values.length) {
+            set._values.push(0);
+        }
+
+        // Pack the value+1 into the slot using assembly
+        assembly {
+            // Calculate storage slot for _values[slotIndex]
+            mstore(0x00, set.slot)
+            let valuesSlot := keccak256(0x00, 0x20)
+            let targetSlot := add(valuesSlot, slotIndex)
+
+            // Load current slot value
+            let slot := sload(targetSlot)
+
+            // Calculate shift amount: offsetInSlot * 16
+            let shiftAmount := shl(4, offsetInSlot)
+
+            // Create mask: 0xFFFF << shiftAmount
+            let mask := shl(shiftAmount, 0xFFFF)
+
+            // Clear the target position and insert value+1
+            // slot = (slot & ~mask) | ((value + 1) << shiftAmount)
+            slot := or(and(slot, not(mask)), shl(shiftAmount, add(value, 1)))
+
+            // Store back
+            sstore(targetSlot, slot)
+        }
+
+        // Store the position (1-indexed) in packed format
+        // Position encodes: ((slotIndex << 4) | offsetInSlot) + 1
+        uint256 position;
+        assembly {
+            position := add(or(shl(4, slotIndex), offsetInSlot), 1)
+        }
+        _setPackedIndex(set._indexesPacked, value, position);
+
+        return true;
+    }
+
+    /**
+     * @dev Removes a value from a set. O(1).
+     * Returns true if the value was removed from the set, that is if it was
+     * present.
+     */
+    function remove(
+        Uint16Set storage set,
+        uint16 value
+    ) internal returns (bool) {
+        uint256 valueIndex = _getPackedIndex(set._indexesPacked, value);
+
+        if (valueIndex == 0) {
+            return false; // Value not in set
+        }
+
+        uint256 lastIndex = length(set) - 1;
+        uint256 valuePosition = valueIndex - 1;
+
+        // Calculate last slot position (used in both branches)
+        uint256 lastSlotIndex;
+        uint256 lastOffsetInSlot;
+        assembly {
+            lastSlotIndex := shr(4, lastIndex)
+            lastOffsetInSlot := and(lastIndex, 0xF)
+        }
+
+        if (lastIndex != valuePosition) {
+            uint256 lastValuePlusOne;
+
+            assembly {
+                // Load last value
+                mstore(0x00, set.slot)
+                let valuesSlot := keccak256(0x00, 0x20)
+                let lastSlot := sload(add(valuesSlot, lastSlotIndex))
+
+                // Extract last value: (lastSlot >> (lastOffsetInSlot * 16)) & 0xFFFF
+                lastValuePlusOne := and(
+                    shr(shl(4, lastOffsetInSlot), lastSlot),
+                    0xFFFF
+                )
+            }
+
+            // Move last value to the removed value's position
+            uint256 valueSlotIndex;
+            uint256 valueOffsetInSlot;
+
+            assembly {
+                valueSlotIndex := shr(4, valuePosition)
+                valueOffsetInSlot := and(valuePosition, 0xF)
+
+                // Calculate storage slot
+                mstore(0x00, set.slot)
+                let valuesSlot := keccak256(0x00, 0x20)
+                let targetSlot := add(valuesSlot, valueSlotIndex)
+
+                // Load current slot
+                let slot := sload(targetSlot)
+
+                // Calculate shift and mask
+                let shiftAmount := shl(4, valueOffsetInSlot)
+                let mask := shl(shiftAmount, 0xFFFF)
+
+                // Update slot: (slot & ~mask) | (lastValuePlusOne << shiftAmount)
+                slot := or(
+                    and(slot, not(mask)),
+                    shl(shiftAmount, lastValuePlusOne)
+                )
+
+                // Store back
+                sstore(targetSlot, slot)
+            }
+
+            // Update the moved value's index
+            _setPackedIndex(
+                set._indexesPacked,
+                uint16(lastValuePlusOne - 1),
+                valueIndex
+            );
+        }
+
+        // Clear the last position
+        bool shouldPop;
+
+        assembly {
+            // Calculate storage slot
+            mstore(0x00, set.slot)
+            let valuesSlot := keccak256(0x00, 0x20)
+            let targetSlot := add(valuesSlot, lastSlotIndex)
+
+            // Load current slot
+            let slot := sload(targetSlot)
+
+            // Clear the position: slot & ~(0xFFFF << (lastOffsetInSlot * 16))
+            let shiftAmount := shl(4, lastOffsetInSlot)
+            let mask := shl(shiftAmount, 0xFFFF)
+            slot := and(slot, not(mask))
+
+            // Store back
+            sstore(targetSlot, slot)
+
+            // Check if we should pop: slot is zero
+            shouldPop := iszero(slot)
+        }
+
+        // Pop the array if the last slot is now empty
+        if (shouldPop && lastSlotIndex == set._values.length - 1) {
+            set._values.pop();
+        }
+
+        // Delete the removed value's packed index
+        _setPackedIndex(set._indexesPacked, value, 0);
+
+        return true;
+    }
+
+    /**
+     * @dev Returns true if the value is in the set. O(1).
+     */
+    function contains(
+        Uint16Set storage set,
+        uint16 value
+    ) internal view returns (bool) {
+        return _getPackedIndex(set._indexesPacked, value) != 0;
+    }
+
+    /**
+     * @dev Returns the number of values in the set. O(1) amortized.
+     * Uses binary search to find the highest populated position in the last slot.
+     */
+    function length(
+        Uint16Set storage set
+    ) internal view returns (uint256 result) {
+        uint256 valuesLength = set._values.length;
+
+        if (valuesLength == 0) {
+            return 0;
+        }
+
+        uint256 lastSlot = set._values[valuesLength - 1];
+
+        // Use binary search to find highest non-zero 16-bit segment
+        uint256 highestOffset;
+        assembly {
+            let slot := lastSlot
+            highestOffset := 0
+
+            // Binary search for highest non-zero segment
+            // Check upper half (bits 128-255)
+            let upper := shr(128, slot)
+            if gt(upper, 0) {
+                highestOffset := 8
+                slot := upper
+            }
+
+            // Check upper 4 positions of current 8-position range
+            upper := shr(64, slot)
+            if gt(upper, 0) {
+                highestOffset := add(highestOffset, 4)
+                slot := upper
+            }
+
+            // Check upper 2 positions of current 4-position range
+            upper := shr(32, slot)
+            if gt(upper, 0) {
+                highestOffset := add(highestOffset, 2)
+                slot := upper
+            }
+
+            // Check upper 1 position of current 2-position range
+            upper := shr(16, slot)
+            if gt(upper, 0) {
+                highestOffset := add(highestOffset, 1)
+            }
+        }
+
+        // Calculate total length: ((valuesLength - 1) * 16) + highestOffset + 1
+        return ((valuesLength - 1) << 4) + highestOffset + 1;
+    }
+
+    /**
+     * @dev Returns the value stored at position `index` in the set. O(1).
+     *
+     * Note that there are no guarantees on the ordering of values inside the
+     * array, and it may change when more values are added or removed.
+     *
+     * Requirements:
+     * - `index` must be strictly less than {length}.
+     */
+    function at(
+        Uint16Set storage set,
+        uint256 index
+    ) internal view returns (uint16) {
+        require(
+            index < length(set),
+            "EnumerableSetUint16: index out of bounds"
+        );
+
+        uint256 result;
+        assembly {
+            // slotIndex = index >> 4
+            let slotIndex := shr(4, index)
+            // offsetInSlot = index & 0xF
+            let offsetInSlot := and(index, 0xF)
+
+            // Load slot value
+            mstore(0x00, set.slot)
+            let valuesSlot := keccak256(0x00, 0x20)
+            let slot := sload(add(valuesSlot, slotIndex))
+
+            // Extract value: (slot >> (offsetInSlot * 16)) & 0xFFFF - 1
+            result := sub(and(shr(shl(4, offsetInSlot), slot), 0xFFFF), 1)
+        }
+
+        return uint16(result);
+    }
+
+    /**
+     * @dev Returns an array containing all values in the set. O(N).
+     *
+     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive.
+     * This is designed to mostly be used by view accessors that are queried without any gas fees.
+     * Developers should keep in mind that this function has an unbounded cost, and using it as part
+     * of a state-changing function may render the function uncallable if the set grows to a point
+     * where copying to memory consumes too much gas to fit in a block.
+     */
+    function values(
+        Uint16Set storage set
+    ) internal view returns (uint256[] memory) {
+        uint256 count = length(set);
+        uint256[] memory result = new uint256[](count);
+
+        for (uint256 i = 0; i < count; i++) {
+            result[i] = at(set, i);
+        }
+
+        return result;
+    }
+
+    /**
+     * @dev Internal helper to get a packed index for a value.
+     * @param packed The packed index mapping.
+     * @param value The uint16 value to look up.
+     * @return position The position (1-indexed, 0 means not present).
+     */
+    function _getPackedIndex(
+        mapping(uint16 => uint256) storage packed,
+        uint16 value
+    ) private view returns (uint256 position) {
+        assembly {
+            // bucketIndex = value >> 4
+            let bucketIndex := shr(4, value)
+            // posInBucket = value & 0xF
+            let posInBucket := and(value, 0xF)
+
+            // Calculate storage slot for packed[bucketIndex]
+            mstore(0x00, bucketIndex)
+            mstore(0x20, packed.slot)
+            let bucketSlot := keccak256(0x00, 0x40)
+
+            // Load bucket
+            let bucket := sload(bucketSlot)
+
+            // Extract position: (bucket >> (posInBucket * 16)) & 0xFFFF
+            position := and(shr(shl(4, posInBucket), bucket), 0xFFFF)
+        }
+    }
+
+    /**
+     * @dev Internal helper to set a packed index for a value.
+     * @param packed The packed index mapping.
+     * @param value The uint16 value to set.
+     * @param position The position to store (1-indexed, 0 means remove).
+     */
+    function _setPackedIndex(
+        mapping(uint16 => uint256) storage packed,
+        uint16 value,
+        uint256 position
+    ) private {
+        assembly {
+            // bucketIndex = value >> 4
+            let bucketIndex := shr(4, value)
+            // posInBucket = value & 0xF
+            let posInBucket := and(value, 0xF)
+
+            // Calculate storage slot for packed[bucketIndex]
+            mstore(0x00, bucketIndex)
+            mstore(0x20, packed.slot)
+            let bucketSlot := keccak256(0x00, 0x40)
+
+            // Load current bucket
+            let bucket := sload(bucketSlot)
+
+            // Calculate shift and mask
+            let shiftAmount := shl(4, posInBucket)
+            let mask := shl(shiftAmount, 0xFFFF)
+
+            // Update bucket: (bucket & ~mask) | (position << shiftAmount)
+            bucket := or(and(bucket, not(mask)), shl(shiftAmount, position))
+
+            // Store back
+            sstore(bucketSlot, bucket)
+        }
+    }
+}