@artblocks/contracts 1.0.4 → 1.2.0

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

@@ -3,6 +3,8 @@
 
 pragma solidity ^0.8.0;
 
+import {DALib} from "./DALib.sol";
+
 /**
  * @title Art Blocks Dutch Auction (exponential price curve) Library
  * @notice This library is designed to implement logic and checks for Art
@@ -12,6 +14,41 @@ pragma solidity ^0.8.0;
  */
 
 library DAExpLib {
+    /**
+     * @notice Auction details set for project `projectId` on core contract
+     * `coreContract`.
+     * @param projectId Project Id for which auction details were set
+     * @param coreContract Core contract address for which auction details were
+     * set
+     * @param auctionTimestampStart Timestamp when auction will start
+     * @param priceDecayHalfLifeSeconds Half life of price decay, in seconds
+     * @param startPrice Start price of auction
+     * @param basePrice Base price of auction (end price)
+     */
+    event SetAuctionDetailsExp(
+        uint256 indexed projectId,
+        address indexed coreContract,
+        uint40 auctionTimestampStart,
+        uint40 priceDecayHalfLifeSeconds,
+        uint256 startPrice,
+        uint256 basePrice
+    );
+
+    /**
+     * @notice Minimum allowed price decay half life on the minter updated to
+     * `minimumPriceDecayHalfLifeSeconds`.
+     * @param minimumPriceDecayHalfLifeSeconds minimum price decay half life
+     * for new auctions, in seconds
+     */
+    event AuctionMinHalfLifeSecondsUpdated(
+        uint256 minimumPriceDecayHalfLifeSeconds
+    );
+
+    // position of DA Exp Lib storage, using a diamond storage pattern
+    // for this library
+    bytes32 constant DAE_EXP_LIB_STORAGE_POSITION =
+        keccak256("daexplib.storage");
+
     struct DAProjectConfig {
         // @dev max uint40 ~= 1.1e12 sec ~= 34 thousand years
         uint40 timestampStart;
@@ -22,6 +59,11 @@ library DAExpLib {
         uint88 basePrice;
     }
 
+    // Diamond storage pattern is used in this library
+    struct DAExpLibStorage {
+        mapping(address coreContract => mapping(uint256 projectId => DAProjectConfig)) DAProjectConfigs_;
+    }
+
     /**
      * @notice Sets auction details for an exponential-price auction type.
      * @dev The function sets the auction start timestamp, price decay
@@ -31,46 +73,78 @@ library DAExpLib {
      * 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
+     * @param projectId The project Id to set auction details for.
+     * @param coreContract The core contract address to set auction details.
+     * @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
+     * @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
+        uint256 projectId,
+        address coreContract,
+        uint40 auctionTimestampStart,
+        uint40 priceDecayHalfLifeSeconds,
+        uint88 startPrice,
+        uint88 basePrice,
+        bool allowReconfigureAfterStart
     ) internal {
+        DAProjectConfig storage DAProjectConfig_ = getDAProjectConfig({
+            projectId: projectId,
+            coreContract: coreContract
+        });
         require(
-            _DAProjectConfig.timestampStart == 0 || // uninitialized
-                block.timestamp < _DAProjectConfig.timestampStart || // auction not yet started
-                _allowReconfigureAfterStart, // specifically allowing reconfiguration after start
+            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,
+            block.timestamp < auctionTimestampStart,
             "Only future auctions"
         );
         require(
-            _startPrice > _basePrice,
+            startPrice > basePrice,
             "Auction start price must be greater than auction end price"
         );
+        // @dev no coverage, as minter auction min half life may be more
+        // restrictive than gt 0
+        require(priceDecayHalfLifeSeconds > 0, "Only half life gt 0");
 
         // EFFECTS
-        _DAProjectConfig.timestampStart = _auctionTimestampStart;
-        _DAProjectConfig.priceDecayHalfLifeSeconds = _priceDecayHalfLifeSeconds;
-        _DAProjectConfig.startPrice = _startPrice;
-        _DAProjectConfig.basePrice = _basePrice;
+        DAProjectConfig_.timestampStart = auctionTimestampStart;
+        DAProjectConfig_.priceDecayHalfLifeSeconds = priceDecayHalfLifeSeconds;
+        DAProjectConfig_.startPrice = startPrice;
+        DAProjectConfig_.basePrice = basePrice;
+
+        emit SetAuctionDetailsExp({
+            projectId: projectId,
+            coreContract: coreContract,
+            auctionTimestampStart: auctionTimestampStart,
+            priceDecayHalfLifeSeconds: priceDecayHalfLifeSeconds,
+            startPrice: startPrice,
+            basePrice: basePrice
+        });
+    }
+
+    function resetAuctionDetails(
+        uint256 projectId,
+        address coreContract
+    ) internal {
+        // @dev all fields must be deleted, and none of them are a complex type
+        // @dev getDAProjectConfig not used, as deletion of storage pointers is
+        // not supported
+        delete s().DAProjectConfigs_[coreContract][projectId];
+
+        emit DALib.ResetAuctionDetails({
+            projectId: projectId,
+            coreContract: coreContract
+        });
     }
 
     /**
@@ -79,30 +153,37 @@ library DAExpLib {
      * This function reverts if auction has not yet started, or if auction is
      * unconfigured, which is relied upon by certain minter implications for
      * security.
+     * @param projectId Project Id to get price for
+     * @param coreContract Core contract address to get price for
      * @return uint256 current price of token in Wei
      */
     function getPriceExp(
-        DAProjectConfig storage _DAProjectConfig
+        uint256 projectId,
+        address coreContract
     ) internal view returns (uint256) {
+        DAProjectConfig storage DAProjectConfig_ = getDAProjectConfig({
+            projectId: projectId,
+            coreContract: coreContract
+        });
         // move parameters to memory if used more than once
-        uint256 _timestampStart = _DAProjectConfig.timestampStart;
-        uint256 _priceDecayHalfLifeSeconds = _DAProjectConfig
+        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;
+        // @dev check also ensures we don't divide by priceDecayHalfLifeSeconds
+        // of zero
+        require(priceDecayHalfLifeSeconds > 0, "Only configured auctions");
+        require(block.timestamp >= timestampStart, "Auction not yet started");
+        uint256 decayedPrice = DAProjectConfig_.startPrice;
         uint256 elapsedTimeSeconds;
         unchecked {
             // already checked that block.timestamp > _timestampStart above
-            elapsedTimeSeconds = block.timestamp - _timestampStart;
+            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;
+            // 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.
@@ -111,15 +192,57 @@ library DAExpLib {
             // so no underflow is possible when the subtraction assignment
             // operator is used on decayedPrice.
             decayedPrice -=
-                (decayedPrice *
-                    (elapsedTimeSeconds % _priceDecayHalfLifeSeconds)) /
-                _priceDecayHalfLifeSeconds /
-                2;
+                ((decayedPrice *
+                    (elapsedTimeSeconds % priceDecayHalfLifeSeconds)) /
+                    priceDecayHalfLifeSeconds) >>
+                1; // divide by 2 via bitshift 1
         }
-        if (decayedPrice < _basePrice) {
+        uint256 basePrice = DAProjectConfig_.basePrice;
+        if (decayedPrice < basePrice) {
             // Price may not decay below stay `basePrice`.
-            return _basePrice;
+            return basePrice;
         }
         return decayedPrice;
     }
+
+    /**
+     * Gets auction base price for project `projectId` on core contract
+     * `coreContract`.
+     * @param projectId Project Id to get price for
+     * @param coreContract Core contract address to get price for
+     */
+    function getAuctionBasePrice(
+        uint256 projectId,
+        address coreContract
+    ) internal view returns (uint256) {
+        return
+            getDAProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            }).basePrice;
+    }
+
+    /**
+     * Loads the DAProjectConfig for a given project and core contract.
+     * @param projectId Project Id to get config for
+     * @param coreContract Core contract address to get config for
+     */
+    function getDAProjectConfig(
+        uint256 projectId,
+        address coreContract
+    ) internal view returns (DAProjectConfig storage) {
+        return s().DAProjectConfigs_[coreContract][projectId];
+    }
+
+    /**
+     * @notice Return the storage struct for reading and writing. This library
+     * uses a diamond storage pattern when managing storage.
+     * @return storageStruct The DAExpLibStorage struct.
+     */
+    function s() internal pure returns (DAExpLibStorage storage storageStruct) {
+        bytes32 position = DAE_EXP_LIB_STORAGE_POSITION;
+        assembly ("memory-safe") {
+            storageStruct.slot := position
+        }
+    }
 }

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

@@ -0,0 +1,26 @@
+// 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 DALib {
+    /**
+     * @notice Auction details cleared for project `projectId` on core contract
+     * `coreContract`.
+     * @param projectId Project Id for which auction details were cleared
+     * @param coreContract Core contract address for which auction details were
+     * cleared
+     */
+    event ResetAuctionDetails(
+        uint256 indexed projectId,
+        address indexed coreContract
+    );
+}

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

@@ -3,15 +3,52 @@
 
 pragma solidity ^0.8.0;
 
+import {DALib} from "./DALib.sol";
+
 /**
  * @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
+ * Blocks projects using an linear Dutch auctionprice curve for minting
  * tokens.
  * @author Art Blocks Inc.
  */
 
 library DALinLib {
+    /**
+     * @notice Auction details set for project `projectId` on core contract
+     * `coreContract`.
+     * @param projectId Project Id for which auction details were set
+     * @param coreContract Core contract address for which auction details were
+     * set
+     * @param auctionTimestampStart Timestamp when auction will start
+     * @param auctionTimestampEnd Timestamp when auction will end
+     * @param startPrice Start price of auction
+     * @param basePrice Base price of auction (end price)
+     */
+    event SetAuctionDetailsLin(
+        uint256 indexed projectId,
+        address indexed coreContract,
+        uint40 auctionTimestampStart,
+        uint40 auctionTimestampEnd,
+        uint256 startPrice,
+        uint256 basePrice
+    );
+
+    /**
+     * @notice Minimum allowed auction length updated to
+     * `minimumAuctionLengthSeconds` on the minter.
+     * @param minimumAuctionLengthSeconds minimum auction length for new
+     * auctions, in seconds
+     */
+    event AuctionMinimumLengthSecondsUpdated(
+        uint256 minimumAuctionLengthSeconds
+    );
+
+    // position of DA Lin Lib storage, using a diamond storage pattern
+    // for this library
+    bytes32 constant DAE_LIN_LIB_STORAGE_POSITION =
+        keccak256("dalinlib.storage");
+
     struct DAProjectConfig {
         // @dev max uint40 ~= 1.1e12 sec ~= 34 thousand years
         uint40 timestampStart;
@@ -22,6 +59,11 @@ library DALinLib {
         uint88 basePrice;
     }
 
+    // Diamond storage pattern is used in this library
+    struct DALinLibStorage {
+        mapping(address coreContract => mapping(uint256 projectId => DAProjectConfig)) DAProjectConfigs_;
+    }
+
     /**
      * @notice Sets auction details for a linear-price auction type.
      * @dev The function sets the auction start timestamp, auction end
@@ -31,45 +73,74 @@ library DALinLib {
      * 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
+     * @param projectId The project Id to set auction details for.
+     * @param coreContract The core contract address to set auction details.
+     * @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
+        uint256 projectId,
+        address coreContract,
+        uint40 auctionTimestampStart,
+        uint40 auctionTimestampEnd,
+        uint88 startPrice,
+        uint88 basePrice,
+        bool allowReconfigureAfterStart
     ) internal {
+        DAProjectConfig storage DAProjectConfig_ = getDAProjectConfig({
+            projectId: projectId,
+            coreContract: coreContract
+        });
         require(
-            _DAProjectConfig.timestampStart == 0 || // uninitialized
-                block.timestamp < _DAProjectConfig.timestampStart || // auction not yet started
-                _allowReconfigureAfterStart, // specifically allowing reconfiguration after start
+            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,
+            block.timestamp < auctionTimestampStart,
             "Only future auctions"
         );
         require(
-            _startPrice > _basePrice,
+            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;
+        DAProjectConfig_.timestampStart = auctionTimestampStart;
+        DAProjectConfig_.timestampEnd = auctionTimestampEnd;
+        DAProjectConfig_.startPrice = startPrice;
+        DAProjectConfig_.basePrice = basePrice;
+
+        emit SetAuctionDetailsLin({
+            projectId: projectId,
+            coreContract: coreContract,
+            auctionTimestampStart: auctionTimestampStart,
+            auctionTimestampEnd: auctionTimestampEnd,
+            startPrice: startPrice,
+            basePrice: basePrice
+        });
+    }
+
+    function resetAuctionDetails(
+        uint256 projectId,
+        address coreContract
+    ) internal {
+        // @dev all fields must be deleted, and none of them are a complex type
+        // @dev getDAProjectConfig not used, as deletion of storage pointers is
+        // not supported
+        delete s().DAProjectConfigs_[coreContract][projectId];
+
+        emit DALib.ResetAuctionDetails({
+            projectId: projectId,
+            coreContract: coreContract
+        });
     }
 
     /**
@@ -77,33 +148,64 @@ library DALinLib {
      * DAProjectConfig.
      * This function reverts if auction has not yet started, or if auction is
      * unconfigured.
+     * @param projectId Project Id to get price for
+     * @param coreContract Core contract address to get price for
      * @return current price of token in Wei
      */
     function getPriceLin(
-        DAProjectConfig storage _DAProjectConfig
+        uint256 projectId,
+        address coreContract
     ) internal view returns (uint256) {
+        DAProjectConfig storage _DAProjectConfig = getDAProjectConfig({
+            projectId: projectId,
+            coreContract: coreContract
+        });
         // 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 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;
+            elapsedTime = block.timestamp - timestampStart;
             // _timestampEnd > _timestampStart enforced during assignment
-            duration = _timestampEnd - _timestampStart;
+            duration = timestampEnd - timestampStart;
             // _startPrice > _basePrice enforced during assignment
-            startToEndDiff = _startPrice - _basePrice;
+            startToEndDiff = startPrice - basePrice;
+        }
+        return startPrice - ((elapsedTime * startToEndDiff) / duration);
+    }
+
+    /**
+     * Loads the DAProjectConfig for a given project and core contract.
+     * @param projectId Project Id to get config for
+     * @param coreContract Core contract address to get config for
+     */
+    function getDAProjectConfig(
+        uint256 projectId,
+        address coreContract
+    ) internal view returns (DAProjectConfig storage) {
+        return s().DAProjectConfigs_[coreContract][projectId];
+    }
+
+    /**
+     * @notice Return the storage struct for reading and writing. This library
+     * uses a diamond storage pattern when managing storage.
+     * @return storageStruct The DALinLibStorage struct.
+     */
+    function s() internal pure returns (DALinLibStorage storage storageStruct) {
+        bytes32 position = DAE_LIN_LIB_STORAGE_POSITION;
+        assembly ("memory-safe") {
+            storageStruct.slot := position
         }
-        return _startPrice - ((elapsedTime * startToEndDiff) / duration);
     }
 }