@artblocks/contracts 1.0.2 → 1.0.4

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

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity >=0.8.0;
+
+/// @notice Read and write to persistent storage at a fraction of the cost.
+/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SSTORE2.sol)
+/// @author Modified from 0xSequence (https://github.com/0xSequence/sstore2/blob/master/contracts/SSTORE2.sol)
+library SSTORE2 {
+    uint256 internal constant DATA_OFFSET = 1; // We skip the first byte as it's a STOP opcode to ensure the contract can't be called.
+
+    /*//////////////////////////////////////////////////////////////
+                               WRITE LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function write(bytes memory data) internal returns (address pointer) {
+        // Prefix the bytecode with a STOP opcode to ensure it cannot be called.
+        bytes memory runtimeCode = abi.encodePacked(hex"00", data);
+
+        bytes memory creationCode = abi.encodePacked(
+            //---------------------------------------------------------------------------------------------------------------//
+            // Opcode  | Opcode + Arguments  | Description  | Stack View                                                     //
+            //---------------------------------------------------------------------------------------------------------------//
+            // 0x60    |  0x600B             | PUSH1 11     | codeOffset                                                     //
+            // 0x59    |  0x59               | MSIZE        | 0 codeOffset                                                   //
+            // 0x81    |  0x81               | DUP2         | codeOffset 0 codeOffset                                        //
+            // 0x38    |  0x38               | CODESIZE     | codeSize codeOffset 0 codeOffset                               //
+            // 0x03    |  0x03               | SUB          | (codeSize - codeOffset) 0 codeOffset                           //
+            // 0x80    |  0x80               | DUP          | (codeSize - codeOffset) (codeSize - codeOffset) 0 codeOffset   //
+            // 0x92    |  0x92               | SWAP3        | codeOffset (codeSize - codeOffset) 0 (codeSize - codeOffset)   //
+            // 0x59    |  0x59               | MSIZE        | 0 codeOffset (codeSize - codeOffset) 0 (codeSize - codeOffset) //
+            // 0x39    |  0x39               | CODECOPY     | 0 (codeSize - codeOffset)                                      //
+            // 0xf3    |  0xf3               | RETURN       |                                                                //
+            //---------------------------------------------------------------------------------------------------------------//
+            hex"60_0B_59_81_38_03_80_92_59_39_F3", // Returns all code in the contract except for the first 11 (0B in hex) bytes.
+            runtimeCode // The bytecode we want the contract to have after deployment. Capped at 1 byte less than the code size limit.
+        );
+
+        /// @solidity memory-safe-assembly
+        assembly {
+            // Deploy a new contract with the generated creation code.
+            // We start 32 bytes into the code to avoid copying the byte length.
+            pointer := create(0, add(creationCode, 32), mload(creationCode))
+        }
+
+        require(pointer != address(0), "DEPLOYMENT_FAILED");
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                               READ LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function read(address pointer) internal view returns (bytes memory) {
+        return
+            readBytecode(
+                pointer,
+                DATA_OFFSET,
+                pointer.code.length - DATA_OFFSET
+            );
+    }
+
+    function read(
+        address pointer,
+        uint256 start
+    ) internal view returns (bytes memory) {
+        start += DATA_OFFSET;
+
+        return readBytecode(pointer, start, pointer.code.length - start);
+    }
+
+    function read(
+        address pointer,
+        uint256 start,
+        uint256 end
+    ) internal view returns (bytes memory) {
+        start += DATA_OFFSET;
+        end += DATA_OFFSET;
+
+        require(pointer.code.length >= end, "OUT_OF_BOUNDS");
+
+        return readBytecode(pointer, start, end - start);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                          INTERNAL HELPER LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function readBytecode(
+        address pointer,
+        uint256 start,
+        uint256 size
+    ) private view returns (bytes memory data) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            // Get a pointer to some free memory.
+            data := mload(0x40)
+
+            // Update the free memory pointer to prevent overriding our data.
+            // We use and(x, not(31)) as a cheaper equivalent to sub(x, mod(x, 32)).
+            // Adding 31 to size and running the result through the logic above ensures
+            // the memory pointer remains word-aligned, following the Solidity convention.
+            mstore(0x40, add(data, and(add(add(size, 32), 31), not(31))))
+
+            // Store the size of the data in the first 32 byte chunk of free memory.
+            mstore(data, size)
+
+            // Copy the code into memory right after the 32 bytes we used to store the size.
+            extcodecopy(pointer, add(data, 32), start, size)
+        }
+    }
+}

package/contracts/libs/v0.8.x/minter-libs/DAExpLib.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Art Blocks Dutch Auction (exponential price curve) Library
+ * @notice This library is designed to implement logic and checks for Art
+ * Blocks projects using an exponential Dutch auctionprice curve for minting
+ * tokens.
+ * @author Art Blocks Inc.
+ */
+
+library DAExpLib {
+    struct DAProjectConfig {
+        // @dev max uint40 ~= 1.1e12 sec ~= 34 thousand years
+        uint40 timestampStart;
+        uint40 priceDecayHalfLifeSeconds;
+        // @dev max uint88 ~= 3e26 Wei = ~300 million ETH, which is well above
+        // the expected prices of any NFT mint in the foreseeable future.
+        uint88 startPrice;
+        uint88 basePrice;
+    }
+
+    /**
+     * @notice Sets auction details for an exponential-price auction type.
+     * @dev The function sets the auction start timestamp, price decay
+     * half-life, starting, and base prices for an exponential-price auction.
+     * @dev Minter implementations should ensure that any additional guard-
+     * rails are properly checked outside of this function. For example, the
+     * minter should check that _priceDecayHalfLifeSeconds is greater than the
+     * minter's minimum allowable value for price decay half-life (if the
+     * minter chooses to include that guard-rail).
+     * @param _DAProjectConfig The storage reference to the DAProjectConfig
+     * struct.
+     * @param _auctionTimestampStart The timestamp when the auction will start.
+     * @param _priceDecayHalfLifeSeconds The half-life time for price decay in
+     * seconds.
+     * @param _startPrice The starting price of the auction.
+     * @param _basePrice The base price of the auction.
+     * @param _allowReconfigureAfterStart Bool indicating whether the auction
+     * can be reconfigured after it has started. This is sometimes useful for
+     * minter implementations that want to allow an artist to reconfigure the
+     * auction after it has reached minter-local max invocations, for example.
+     */
+    function setAuctionDetailsExp(
+        DAProjectConfig storage _DAProjectConfig,
+        uint40 _auctionTimestampStart,
+        uint40 _priceDecayHalfLifeSeconds,
+        uint88 _startPrice,
+        uint88 _basePrice,
+        bool _allowReconfigureAfterStart
+    ) internal {
+        require(
+            _DAProjectConfig.timestampStart == 0 || // uninitialized
+                block.timestamp < _DAProjectConfig.timestampStart || // auction not yet started
+                _allowReconfigureAfterStart, // specifically allowing reconfiguration after start
+            "No modifications mid-auction"
+        );
+        require(
+            block.timestamp < _auctionTimestampStart,
+            "Only future auctions"
+        );
+        require(
+            _startPrice > _basePrice,
+            "Auction start price must be greater than auction end price"
+        );
+
+        // EFFECTS
+        _DAProjectConfig.timestampStart = _auctionTimestampStart;
+        _DAProjectConfig.priceDecayHalfLifeSeconds = _priceDecayHalfLifeSeconds;
+        _DAProjectConfig.startPrice = _startPrice;
+        _DAProjectConfig.basePrice = _basePrice;
+    }
+
+    /**
+     * @notice Gets price of minting a token given the project's
+     * DAProjectConfig.
+     * This function reverts if auction has not yet started, or if auction is
+     * unconfigured, which is relied upon by certain minter implications for
+     * security.
+     * @return uint256 current price of token in Wei
+     */
+    function getPriceExp(
+        DAProjectConfig storage _DAProjectConfig
+    ) internal view returns (uint256) {
+        // move parameters to memory if used more than once
+        uint256 _timestampStart = _DAProjectConfig.timestampStart;
+        uint256 _priceDecayHalfLifeSeconds = _DAProjectConfig
+            .priceDecayHalfLifeSeconds;
+        uint256 _basePrice = _DAProjectConfig.basePrice;
+
+        require(block.timestamp > _timestampStart, "Auction not yet started");
+        require(_priceDecayHalfLifeSeconds > 0, "Only configured auctions");
+        uint256 decayedPrice = _DAProjectConfig.startPrice;
+        uint256 elapsedTimeSeconds;
+        unchecked {
+            // already checked that block.timestamp > _timestampStart above
+            elapsedTimeSeconds = block.timestamp - _timestampStart;
+        }
+        // Divide by two (via bit-shifting) for the number of entirely completed
+        // half-lives that have elapsed since auction start time.
+        unchecked {
+            // already required _priceDecayHalfLifeSeconds > 0
+            decayedPrice >>= elapsedTimeSeconds / _priceDecayHalfLifeSeconds;
+        }
+        // Perform a linear interpolation between partial half-life points, to
+        // approximate the current place on a perfect exponential decay curve.
+        unchecked {
+            // value of expression is provably always less than decayedPrice,
+            // so no underflow is possible when the subtraction assignment
+            // operator is used on decayedPrice.
+            decayedPrice -=
+                (decayedPrice *
+                    (elapsedTimeSeconds % _priceDecayHalfLifeSeconds)) /
+                _priceDecayHalfLifeSeconds /
+                2;
+        }
+        if (decayedPrice < _basePrice) {
+            // Price may not decay below stay `basePrice`.
+            return _basePrice;
+        }
+        return decayedPrice;
+    }
+}

package/contracts/libs/v0.8.x/minter-libs/DALinLib.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Art Blocks Dutch Auction (linear price curve) Library
+ * @notice This library is designed to implement logic and checks for Art
+ * Blocks projects using an exponential Dutch auctionprice curve for minting
+ * tokens.
+ * @author Art Blocks Inc.
+ */
+
+library DALinLib {
+    struct DAProjectConfig {
+        // @dev max uint40 ~= 1.1e12 sec ~= 34 thousand years
+        uint40 timestampStart;
+        uint40 timestampEnd;
+        // @dev max uint88 ~= 3e26 Wei = ~300 million ETH, which is well above
+        // the expected prices of any NFT mint in the foreseeable future.
+        uint88 startPrice;
+        uint88 basePrice;
+    }
+
+    /**
+     * @notice Sets auction details for a linear-price auction type.
+     * @dev The function sets the auction start timestamp, auction end
+     * timestamp, starting, and base prices for a linear-price auction.
+     * @dev Minter implementations should ensure that any additional guard-
+     * rails are properly checked outside of this function. For example, the
+     * minter should check that auction length is greater than the minter's
+     * minimum allowable value (if the minter chooses to include that guard-
+     * rail).
+     * @param _DAProjectConfig The storage reference to the DAProjectConfig
+     * struct.
+     * @param _auctionTimestampStart The timestamp when the auction will start.
+     * @param _auctionTimestampEnd The timestamp when the auction will end.
+     * @param _startPrice The starting price of the auction.
+     * @param _basePrice The base price of the auction.
+     * @param _allowReconfigureAfterStart Bool indicating whether the auction
+     * can be reconfigured after it has started. This is sometimes useful for
+     * minter implementations that want to allow an artist to reconfigure the
+     * auction after it has reached minter-local max invocations, for example.
+     */
+    function setAuctionDetailsLin(
+        DAProjectConfig storage _DAProjectConfig,
+        uint40 _auctionTimestampStart,
+        uint40 _auctionTimestampEnd,
+        uint88 _startPrice,
+        uint88 _basePrice,
+        bool _allowReconfigureAfterStart
+    ) internal {
+        require(
+            _DAProjectConfig.timestampStart == 0 || // uninitialized
+                block.timestamp < _DAProjectConfig.timestampStart || // auction not yet started
+                _allowReconfigureAfterStart, // specifically allowing reconfiguration after start
+            "No modifications mid-auction"
+        );
+        require(
+            block.timestamp < _auctionTimestampStart,
+            "Only future auctions"
+        );
+        require(
+            _startPrice > _basePrice,
+            "Auction start price must be greater than auction end price"
+        );
+
+        // EFFECTS
+        _DAProjectConfig.timestampStart = _auctionTimestampStart;
+        _DAProjectConfig.timestampEnd = _auctionTimestampEnd;
+        _DAProjectConfig.startPrice = _startPrice;
+        _DAProjectConfig.basePrice = _basePrice;
+    }
+
+    /**
+     * @notice Gets price of minting a token given the project's
+     * DAProjectConfig.
+     * This function reverts if auction has not yet started, or if auction is
+     * unconfigured.
+     * @return current price of token in Wei
+     */
+    function getPriceLin(
+        DAProjectConfig storage _DAProjectConfig
+    ) internal view returns (uint256) {
+        // move parameters to memory if used more than once
+        uint256 _timestampStart = _DAProjectConfig.timestampStart;
+        uint256 _timestampEnd = _DAProjectConfig.timestampEnd;
+        uint256 _startPrice = _DAProjectConfig.startPrice;
+        uint256 _basePrice = _DAProjectConfig.basePrice;
+
+        require(block.timestamp > _timestampStart, "Auction not yet started");
+        if (block.timestamp >= _timestampEnd) {
+            require(_timestampEnd > 0, "Only configured auctions");
+            return _basePrice;
+        }
+        uint256 elapsedTime;
+        uint256 duration;
+        uint256 startToEndDiff;
+        unchecked {
+            // already checked that block.timestamp > _timestampStart
+            elapsedTime = block.timestamp - _timestampStart;
+            // _timestampEnd > _timestampStart enforced during assignment
+            duration = _timestampEnd - _timestampStart;
+            // _startPrice > _basePrice enforced during assignment
+            startToEndDiff = _startPrice - _basePrice;
+        }
+        return _startPrice - ((elapsedTime * startToEndDiff) / duration);
+    }
+}