@artblocks/contracts 1.0.4 → 1.1.0

package/contracts/minter-suite/Minters/MinterDAExpSettlementV3.sol

@@ -1,23 +1,25 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
 
-import "../../interfaces/v0.8.x/ISharedMinterSimplePurchaseV0.sol";
-import "../../interfaces/v0.8.x/ISharedMinterV0.sol";
-import "../../interfaces/v0.8.x/ISharedMinterDAV0.sol";
-import "../../interfaces/v0.8.x/ISharedMinterDAExpV0.sol";
-import "../../interfaces/v0.8.x/ISharedMinterDAExpSettlementV0.sol";
-import "../../interfaces/v0.8.x/IMinterFilterV1.sol";
+// @dev fixed to specific solidity version for clarity and for more clear
+// source code verification purposes.
+pragma solidity 0.8.19;
 
-import "../../libs/v0.8.x/minter-libs/SettlementExpLib.sol";
-import "../../libs/v0.8.x/minter-libs/SplitFundsLib.sol";
-import "../../libs/v0.8.x/minter-libs/MaxInvocationsLib.sol";
-import "../../libs/v0.8.x/minter-libs/DAExpLib.sol";
-import "../../libs/v0.8.x/AuthLib.sol";
+import {ISharedMinterSimplePurchaseV0} from "../../interfaces/v0.8.x/ISharedMinterSimplePurchaseV0.sol";
+import {ISharedMinterV0} from "../../interfaces/v0.8.x/ISharedMinterV0.sol";
+import {ISharedMinterDAV0} from "../../interfaces/v0.8.x/ISharedMinterDAV0.sol";
+import {ISharedMinterDAExpV0} from "../../interfaces/v0.8.x/ISharedMinterDAExpV0.sol";
+import {ISharedMinterDAExpSettlementV0} from "../../interfaces/v0.8.x/ISharedMinterDAExpSettlementV0.sol";
+import {IMinterFilterV1} from "../../interfaces/v0.8.x/IMinterFilterV1.sol";
 
-import "@openzeppelin-4.7/contracts/utils/math/SafeCast.sol";
-import "@openzeppelin-4.5/contracts/security/ReentrancyGuard.sol";
+import {SettlementExpLib} from "../../libs/v0.8.x/minter-libs/SettlementExpLib.sol";
+import {SplitFundsLib} from "../../libs/v0.8.x/minter-libs/SplitFundsLib.sol";
+import {MaxInvocationsLib} from "../../libs/v0.8.x/minter-libs/MaxInvocationsLib.sol";
+import {DAExpLib} from "../../libs/v0.8.x/minter-libs/DAExpLib.sol";
+import {AuthLib} from "../../libs/v0.8.x/AuthLib.sol";
 
-pragma solidity 0.8.19;
+import {SafeCast} from "@openzeppelin-4.7/contracts/utils/math/SafeCast.sol";
+import {ReentrancyGuard} from "@openzeppelin-4.5/contracts/security/ReentrancyGuard.sol";
 
 /**
  * @title Shared, filtered Minter contract that allows tokens to be minted with
@@ -51,7 +53,6 @@ pragma solidity 0.8.19;
  * contract:
  * - resetAuctionDetails (note: this will prevent minting until a new auction
  *   is created)
- * - adminEmergencyReduceSelloutPrice
  * ----------------------------------------------------------------------------
  * The following functions are restricted to a project's artist or the core
  * contract's Admin ACL contract:
@@ -67,6 +68,13 @@ pragma solidity 0.8.19;
  * ----------------------------------------------------------------------------
  * Additional admin and artist privileged roles may be described on other
  * contracts that this minter integrates with.
+ * ----------------------------------------------------------------------------
+ * @notice Caution: While Engine projects must be registered on the Art Blocks
+ * Core Registry to assign this minter, this minter does not enforce that a
+ * project is registered when configured or queried. This is primarily for gas
+ * optimization purposes. It is, therefore, possible that fake projects may be
+ * configured on this minter, but they will not be able to mint tokens due to
+ * checks performed by this minter's Minter Filter.
  *
  * @dev Note that while this minter makes use of `block.timestamp` and it is
  * technically possible that this value is manipulated by block producers via
@@ -86,192 +94,128 @@ contract MinterDAExpSettlementV3 is
 {
     using SafeCast for uint256;
 
-    /// Minter filter address this minter interacts with
+    /// @notice Minter filter address this minter interacts with
     address public immutable minterFilterAddress;
 
-    /// Minter filter this minter may interact with.
-    IMinterFilterV1 private immutable minterFilter;
+    /// @notice Minter filter this minter may interact with.
+    IMinterFilterV1 private immutable _minterFilter;
 
-    /// minterType for this minter
+    /// @notice minterType for this minter
     string public constant minterType = "MinterDAExpSettlementV3";
 
-    /// minter version for this minter
+    /// @notice minter version for this minter
     string public constant minterVersion = "v3.0.0";
 
-    /// Minimum price decay half life: price can decay with a half life of a
+    /// @notice Minimum price decay half life: price can decay with a half life of a
     /// minimum of this amount (can cut in half a minimum of every N seconds).
     uint256 public minimumPriceDecayHalfLifeSeconds = 45; // 45 seconds
 
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR SplitFundsLib begin here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    // contractAddress => IsEngineCache
-    mapping(address => SplitFundsLib.IsEngineCache) private _isEngineCaches;
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR SplitFundsLib end here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR SettlementExpLib begin here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    mapping(address => mapping(uint256 => SettlementExpLib.SettlementAuctionProjectConfig))
-        private _settlementAuctionProjectConfigMapping;
-
-    /// user address => contractAddress => project ID => receipt
-    mapping(address => mapping(address => mapping(uint256 => SettlementExpLib.Receipt)))
-        private _receiptsMapping;
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR SettlementExpLib end here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR DAExpLib begin here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    mapping(address => mapping(uint256 => DAExpLib.DAProjectConfig))
-        private _auctionProjectConfigMapping;
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR DAExpLib end here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR MaxInvocationsLib begin here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    // contractAddress => projectId => max invocations specific project config
-    mapping(address => mapping(uint256 => MaxInvocationsLib.MaxInvocationsProjectConfig))
-        private _maxInvocationsProjectConfigMapping;
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR MaxInvocationsLib end here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
     /**
      * @notice Initializes contract to be a Filtered Minter for
-     * `_minterFilter` minter filter.
-     * @param _minterFilter Minter filter for which this will be a
+     * `minterFilter` minter filter.
+     * @param minterFilter Minter filter for which this will be a
      * filtered minter.
      */
-    constructor(address _minterFilter) ReentrancyGuard() {
-        minterFilterAddress = _minterFilter;
-        minterFilter = IMinterFilterV1(_minterFilter);
-        emit AuctionMinHalfLifeSecondsUpdated(minimumPriceDecayHalfLifeSeconds);
+    constructor(address minterFilter) ReentrancyGuard() {
+        minterFilterAddress = minterFilter;
+        _minterFilter = IMinterFilterV1(minterFilter);
+        emit DAExpLib.AuctionMinHalfLifeSecondsUpdated(
+            minimumPriceDecayHalfLifeSeconds
+        );
     }
 
     /**
-     * @notice Manually sets the local maximum invocations of project `_projectId`
-     * with the provided `_maxInvocations`, checking that `_maxInvocations` is less
-     * than or equal to the value of project `_project_id`'s maximum invocations that is
+     * @notice Manually sets the local maximum invocations of project `projectId`
+     * with the provided `maxInvocations`, checking that `maxInvocations` is less
+     * than or equal to the value of project `project_id`'s maximum invocations that is
      * set on the core contract.
-     * @dev Note that a `_maxInvocations` of 0 can only be set if the current `invocations`
+     * @dev Note that a `maxInvocations` of 0 can only be set if the current `invocations`
      * value is also 0 and this would also set `maxHasBeenInvoked` to true, correctly short-circuiting
      * this minter's purchase function, avoiding extra gas costs from the core contract's maxInvocations check.
-     * @param _projectId Project ID to set the maximum invocations for.
-     * @param _coreContract Core contract address for the given project.
-     * @param _maxInvocations Maximum invocations to set for the project.
+     * @param projectId Project ID to set the maximum invocations for.
+     * @param coreContract Core contract address for the given project.
+     * @param maxInvocations Maximum invocations to set for the project.
      */
     function manuallyLimitProjectMaxInvocations(
-        uint256 _projectId,
-        address _coreContract,
-        uint24 _maxInvocations
+        uint256 projectId,
+        address coreContract,
+        uint24 maxInvocations
     ) external {
         AuthLib.onlyArtist({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender
         });
+        // @dev guard rail to prevent accidentally adjusting max invocations
+        // after one or more purchases have been made
+        require(
+            SettlementExpLib.getNumPurchasesOnMinter({
+                projectId: projectId,
+                coreContract: coreContract
+            }) == 0,
+            "Only before purchases"
+        );
         MaxInvocationsLib.manuallyLimitProjectMaxInvocations({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _maxInvocations: _maxInvocations,
-            maxInvocationsProjectConfig: _maxInvocationsProjectConfigMapping[
-                _coreContract
-            ][_projectId]
+            projectId: projectId,
+            coreContract: coreContract,
+            maxInvocations: maxInvocations
         });
-
-        emit ProjectMaxInvocationsLimitUpdated(
-            _projectId,
-            _coreContract,
-            _maxInvocations
-        );
     }
 
     /**
-     * @notice Sets auction details for project `_projectId`.
-     * @param _projectId Project ID to set auction details for.
-     * @param _coreContract Core contract address for the given project.
-     * @param _auctionTimestampStart Timestamp at which to start the auction.
-     * @param _priceDecayHalfLifeSeconds The half life with which to decay the
+     * @notice Sets auction details for project `projectId`.
+     * @param projectId Project ID to set auction details for.
+     * @param coreContract Core contract address for the given project.
+     * @param auctionTimestampStart Timestamp at which to start the auction.
+     * @param priceDecayHalfLifeSeconds The half life with which to decay the
      *  price (in seconds).
-     * @param _startPrice Price at which to start the auction, in Wei.
-     * @param _basePrice Resting price of the auction, in Wei.
-     * @dev Note that it is intentionally supported here that the configured
-     * price may be explicitly set to `0`.
+     * @param startPrice Price at which to start the auction, in Wei.
+     * @param basePrice Resting price of the auction, in Wei.
+     * @dev Note that a basePrice of `0` will cause the transaction to revert.
      */
     function setAuctionDetails(
-        uint256 _projectId,
-        address _coreContract,
-        uint40 _auctionTimestampStart,
-        uint40 _priceDecayHalfLifeSeconds,
-        uint256 _startPrice,
-        uint256 _basePrice
+        uint256 projectId,
+        address coreContract,
+        uint40 auctionTimestampStart,
+        uint40 priceDecayHalfLifeSeconds,
+        uint256 startPrice,
+        uint256 basePrice
     ) external {
         AuthLib.onlyArtist({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender
         });
         // CHECKS
-        DAExpLib.DAProjectConfig
-            storage _auctionProjectConfig = _auctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-
         // require valid start price on a settlement minter
         require(
             SettlementExpLib.isValidStartPrice({
-                _startPrice: _startPrice,
-                _settlementAuctionProjectConfig: _settlementAuctionProjectConfig
+                projectId: projectId,
+                coreContract: coreContract,
+                startPrice: startPrice
             }),
             "Only monotonic decreasing price"
         );
         // do not allow a base price of zero (to simplify logic on this minter)
-        require(_basePrice > 0, "Base price must be non-zero");
+        require(basePrice > 0, "Base price must be non-zero");
         // require valid half life for this minter
         require(
-            (_priceDecayHalfLifeSeconds >= minimumPriceDecayHalfLifeSeconds),
+            (priceDecayHalfLifeSeconds >= minimumPriceDecayHalfLifeSeconds),
             "Price decay half life must be greater than min allowable value"
         );
 
         // EFFECTS
         DAExpLib.setAuctionDetailsExp({
-            _DAProjectConfig: _auctionProjectConfig,
-            _auctionTimestampStart: _auctionTimestampStart,
-            _priceDecayHalfLifeSeconds: _priceDecayHalfLifeSeconds,
-            _startPrice: _startPrice.toUint88(),
-            _basePrice: _basePrice.toUint88(),
+            projectId: projectId,
+            coreContract: coreContract,
+            auctionTimestampStart: auctionTimestampStart,
+            priceDecayHalfLifeSeconds: priceDecayHalfLifeSeconds,
+            startPrice: startPrice.toUint88(),
+            basePrice: basePrice.toUint88(),
             // we set this to false so it prevents artist from altering auction
             // even after max has been invoked (require explicit auction reset
             // on settlement minter)
-            _allowReconfigureAfterStart: false
-        });
-
-        emit SetAuctionDetailsExp({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _auctionTimestampStart: _auctionTimestampStart,
-            _priceDecayHalfLifeSeconds: _priceDecayHalfLifeSeconds,
-            _startPrice: _startPrice,
-            _basePrice: _basePrice
+            allowReconfigureAfterStart: false
         });
 
         // refresh max invocations, ensuring the values are populated, and
@@ -279,154 +223,81 @@ contract MinterDAExpSettlementV3 is
         // current core contract state.
         // @dev this refresh enables the guarantee that a project's max
         // invocation state is always populated if an auction is configured.
-        MaxInvocationsLib.MaxInvocationsProjectConfig
-            storage _maxInvocationsProjectConfig = _maxInvocationsProjectConfigMapping[
-                _coreContract
-            ][_projectId];
         // @dev this minter pays the higher gas cost of a full refresh here due
         // to the more severe ux degredation of a stale minter-local max
         // invocations state.
-        bool maxInvocationsUpdated = MaxInvocationsLib.refreshMaxInvocations(
-            _projectId,
-            _coreContract,
-            _maxInvocationsProjectConfig
-        );
-
-        // emit event to update state
-        if (maxInvocationsUpdated) {
-            emit ProjectMaxInvocationsLimitUpdated(
-                _projectId,
-                _coreContract,
-                _maxInvocationsProjectConfig.maxInvocations
-            );
-        }
+        MaxInvocationsLib.refreshMaxInvocations({
+            projectId: projectId,
+            coreContract: coreContract
+        });
     }
 
     /**
      * @notice Sets the minimum and maximum values that are settable for
-     * `_priceDecayHalfLifeSeconds` across all projects.
-     * @param _minimumPriceDecayHalfLifeSeconds Minimum price decay half life
+     * `priceDecayHalfLifeSeconds` across all projects.
+     * @param minimumPriceDecayHalfLifeSeconds_ Minimum price decay half life
      * (in seconds).
      */
     function setMinimumPriceDecayHalfLifeSeconds(
-        uint256 _minimumPriceDecayHalfLifeSeconds
+        uint256 minimumPriceDecayHalfLifeSeconds_
     ) external {
         AuthLib.onlyMinterFilterAdminACL({
-            _minterFilterAddress: minterFilterAddress,
-            _sender: msg.sender,
-            _contract: address(this),
-            _selector: this.setMinimumPriceDecayHalfLifeSeconds.selector
+            minterFilterAddress: minterFilterAddress,
+            sender: msg.sender,
+            contract_: address(this),
+            selector: this.setMinimumPriceDecayHalfLifeSeconds.selector
         });
         require(
-            _minimumPriceDecayHalfLifeSeconds > 0,
+            minimumPriceDecayHalfLifeSeconds_ > 0,
             "Half life of zero not allowed"
         );
-        minimumPriceDecayHalfLifeSeconds = _minimumPriceDecayHalfLifeSeconds;
+        minimumPriceDecayHalfLifeSeconds = minimumPriceDecayHalfLifeSeconds_;
 
-        emit AuctionMinHalfLifeSecondsUpdated(
-            _minimumPriceDecayHalfLifeSeconds
+        emit DAExpLib.AuctionMinHalfLifeSecondsUpdated(
+            minimumPriceDecayHalfLifeSeconds_
         );
     }
 
     /**
-     * @notice Resets auction details for project `_projectId`, zero-ing out all
+     * @notice Resets auction details for project `projectId`, zero-ing out all
      * relevant auction fields. Not intended to be used in normal auction
      * operation, but rather only in case of the need to halt an auction.
-     * @param _projectId Project ID to set auction details for.
+     * @param projectId Project ID to set auction details for.
+     * @param coreContract Core contract address for the given project.
      */
     function resetAuctionDetails(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     ) external {
         AuthLib.onlyCoreAdminACL({
-            _coreContract: _coreContract,
-            _sender: msg.sender,
-            _contract: address(this),
-            _selector: this.resetAuctionDetails.selector
+            coreContract: coreContract,
+            sender: msg.sender,
+            contract_: address(this),
+            selector: this.resetAuctionDetails.selector
         });
 
         SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
+            storage settlementAuctionProjectConfig = SettlementExpLib
+                .getSettlementAuctionProjectConfig({
+                    projectId: projectId,
+                    coreContract: coreContract
+                });
 
         // no reset after revenues collected, since that solidifies amount due
         require(
-            !_settlementAuctionProjectConfig.auctionRevenuesCollected,
+            !settlementAuctionProjectConfig.auctionRevenuesCollected,
             "Only before revenues collected"
         );
 
         // EFFECTS
         // delete auction parameters
-        delete _auctionProjectConfigMapping[_coreContract][_projectId];
+        DAExpLib.resetAuctionDetails({
+            projectId: projectId,
+            coreContract: coreContract
+        });
 
         // @dev do NOT delete settlement parameters, as they are used to
         // determine settlement amounts even through a reset
-
-        // @dev V3: changed this event to be fully consistent with
-        // non-settlement minters, as the settlement-specific parameters were
-        // not being used for any indexing purposes
-        emit ResetAuctionDetails(_projectId, _coreContract);
-    }
-
-    /**
-     * @notice This represents an admin stepping in and reducing the sellout
-     * price of an auction. This is only callable by the core admin, only
-     * after the auction is complete, but before project revenues are
-     * withdrawn.
-     * This is only intended to be used in the case where for some reason, the
-     * sellout price was too high.
-     * @param _projectId Project ID to reduce auction sellout price for.
-     * @param _newSelloutPrice New sellout price to set for the auction. Must
-     * be less than the current sellout price.
-     */
-    function adminEmergencyReduceSelloutPrice(
-        uint256 _projectId,
-        address _coreContract,
-        uint128 _newSelloutPrice
-    ) external {
-        AuthLib.onlyCoreAdminACL({
-            _coreContract: _coreContract,
-            _sender: msg.sender,
-            _contract: address(this),
-            _selector: this.adminEmergencyReduceSelloutPrice.selector
-        });
-
-        SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        MaxInvocationsLib.MaxInvocationsProjectConfig
-            storage _maxInvocationsProjectConfig = _maxInvocationsProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        DAExpLib.DAProjectConfig
-            storage _auctionProjectConfig = _auctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-
-        bool maxInvocationsUpdated = SettlementExpLib
-            .adminEmergencyReduceSelloutPrice({
-                _projectId: _projectId,
-                _coreContract: _coreContract,
-                _newSelloutPrice: _newSelloutPrice,
-                _settlementAuctionProjectConfig: _settlementAuctionProjectConfig,
-                _maxInvocationsProjectConfig: _maxInvocationsProjectConfig,
-                _DAProjectConfig: _auctionProjectConfig
-            });
-        emit ConfigValueSet(
-            _projectId,
-            _coreContract,
-            SettlementExpLib.CONFIG_CURRENT_SETTLED_PRICE,
-            uint256(_newSelloutPrice)
-        );
-        if (maxInvocationsUpdated) {
-            emit ProjectMaxInvocationsLimitUpdated(
-                _projectId,
-                _coreContract,
-                _maxInvocationsProjectConfig.maxInvocations
-            );
-        }
     }
 
     /**
@@ -441,70 +312,36 @@ contract MinterDAExpSettlementV3 is
      * After revenues are collected, auction parameters will never be allowed
      * to be reset, and excess settlement funds will become immutable and fully
      * deterministic.
+     * @param projectId Project ID to withdraw revenues for.
+     * @param coreContract Core contract address for the given project.
      */
     function withdrawArtistAndAdminRevenues(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     ) external nonReentrant {
         AuthLib.onlyCoreAdminACLOrArtist({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender,
-            _contract: address(this),
-            _selector: this.adminEmergencyReduceSelloutPrice.selector
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender,
+            contract_: address(this),
+            selector: this.withdrawArtistAndAdminRevenues.selector
         });
 
-        SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        MaxInvocationsLib.MaxInvocationsProjectConfig
-            storage _maxInvocationsProjectConfig = _maxInvocationsProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        DAExpLib.DAProjectConfig
-            storage _auctionProjectConfig = _auctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-
         // @dev the following function affects settlement state and marks
-        // revenues as collected. Therefore revenues MUST be subsequently sent
-        // distributed in this call.
-        // @dev getting isEngine is considered a potential interaction, but
-        // with a trusted contract, and therefore may be done prior to some
-        // checks and effects
-        bool isEngine = SplitFundsLib.isEngine(
-            _coreContract,
-            _isEngineCaches[_coreContract]
-        );
+        // revenues as collected, as well as distributes revenues.
         // CHECKS-EFFECTS-INTERACTIONS
-        bool maxInvocationsUpdated = SettlementExpLib
-            .distributeArtistAndAdminRevenues({
-                _projectId: _projectId,
-                _coreContract: _coreContract,
-                _settlementAuctionProjectConfig: _settlementAuctionProjectConfig,
-                _maxInvocationsProjectConfig: _maxInvocationsProjectConfig,
-                _DAProjectConfig: _auctionProjectConfig,
-                _isEngine: isEngine
-            });
-        emit ConfigValueSet(
-            _projectId,
-            _coreContract,
-            SettlementExpLib.CONFIG_AUCTION_REVENUES_COLLECTED,
-            true
-        );
-        if (maxInvocationsUpdated) {
-            emit ProjectMaxInvocationsLimitUpdated(
-                _projectId,
-                _coreContract,
-                _maxInvocationsProjectConfig.maxInvocations
-            );
-        }
+        // @dev the following function updates the project's balance and will
+        // revert if the project's balance is insufficient to cover the
+        // settlement amount (which is expected to not be possible)
+        SettlementExpLib.distributeArtistAndAdminRevenues({
+            projectId: projectId,
+            coreContract: coreContract
+        });
     }
 
     /**
      * @notice Reclaims the sender's payment above current settled price for
-     * project `_projectId` on core contract `_coreContract`.
+     * project `projectId` on core contract `coreContract`.
      * The current settled price is the the price paid for the most recently
      * purchased token, or the base price if the artist has withdrawn revenues
      * after the auction reached base price.
@@ -513,23 +350,23 @@ contract MinterDAExpSettlementV3 is
      * has been purchased at base price. This minimizes the amount of gas
      * required to send all excess settlement funds to the sender.
      * Sends excess settlement funds to msg.sender.
-     * @param _projectId Project ID to reclaim excess settlement funds on.
-     * @param _coreContract Contract address of the core contract
+     * @param projectId Project ID to reclaim excess settlement funds on.
+     * @param coreContract Contract address of the core contract
      */
     function reclaimProjectExcessSettlementFunds(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     ) external {
-        reclaimProjectExcessSettlementFundsTo(
-            payable(msg.sender),
-            _projectId,
-            _coreContract
-        );
+        reclaimProjectExcessSettlementFundsTo({
+            to: payable(msg.sender),
+            projectId: projectId,
+            coreContract: coreContract
+        });
     }
 
     /**
      * @notice Reclaims the sender's payment above current settled price for
-     * projects in `_projectIds`. The current settled price is the the price
+     * projects in `projectIds`. The current settled price is the the price
      * paid for the most recently purchased token, or the base price if the
      * artist has withdrawn revenues after the auction reached base price.
      * This function is callable at any point, but is expected to typically be
@@ -539,37 +376,37 @@ contract MinterDAExpSettlementV3 is
      * Sends total of all excess settlement funds to msg.sender in a single
      * chunk. Entire transaction reverts if any excess settlement calculation
      * fails.
-     * @param _projectIds Array of project IDs to reclaim excess settlement
+     * @param projectIds Array of project IDs to reclaim excess settlement
      * funds on.
-     * @param _coreContracts Array of core contract addresses for the given
-     * projects. Must be in the same order as `_projectIds` (aligned by index).
+     * @param coreContracts Array of core contract addresses for the given
+     * projects. Must be in the same order as `projectIds` (aligned by index).
      */
     function reclaimProjectsExcessSettlementFunds(
-        uint256[] calldata _projectIds,
-        address[] calldata _coreContracts
+        uint256[] calldata projectIds,
+        address[] calldata coreContracts
     ) external {
         // @dev input validation checks are performed in subcall
-        reclaimProjectsExcessSettlementFundsTo(
-            payable(msg.sender),
-            _projectIds,
-            _coreContracts
-        );
+        reclaimProjectsExcessSettlementFundsTo({
+            to: payable(msg.sender),
+            projectIds: projectIds,
+            coreContracts: coreContracts
+        });
     }
 
     /**
-     * @notice Purchases a token from project `_projectId`.
-     * @param _projectId Project ID to mint a token on.
-     * @param _coreContract Core contract address for the given project.
+     * @notice Purchases a token from project `projectId`.
+     * @param projectId Project ID to mint a token on.
+     * @param coreContract Core contract address for the given project.
      * @return tokenId Token ID of minted token
      */
     function purchase(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     ) external payable returns (uint256 tokenId) {
         tokenId = purchaseTo({
-            _to: msg.sender,
-            _projectId: _projectId,
-            _coreContract: _coreContract
+            to: msg.sender,
+            projectId: projectId,
+            coreContract: coreContract
         });
 
         return tokenId;
@@ -578,26 +415,30 @@ contract MinterDAExpSettlementV3 is
     // public getter functions
     /**
      * @notice Gets the maximum invocations project configuration.
-     * @param _coreContract The address of the core contract.
-     * @param _projectId The ID of the project whose data needs to be fetched.
+     * @param coreContract The address of the core contract.
+     * @param projectId The ID of the project whose data needs to be fetched.
      * @return MaxInvocationsLib.MaxInvocationsProjectConfig instance with the
      * configuration data.
      */
     function maxInvocationsProjectConfig(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     )
         external
         view
         returns (MaxInvocationsLib.MaxInvocationsProjectConfig memory)
     {
-        return _maxInvocationsProjectConfigMapping[_coreContract][_projectId];
+        return
+            MaxInvocationsLib.getMaxInvocationsProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            });
     }
 
     /**
      * @notice Retrieves the auction parameters for a specific project.
-     * @param _projectId The unique identifier for the project.
-     * @param _coreContract The address of the core contract for the project.
+     * @param projectId The unique identifier for the project.
+     * @param coreContract The address of the core contract for the project.
      * @return timestampStart The start timestamp for the auction.
      * @return priceDecayHalfLifeSeconds The half-life for the price decay
      * during the auction, in seconds.
@@ -605,8 +446,8 @@ contract MinterDAExpSettlementV3 is
      * @return basePrice The base price of the auction.
      */
     function projectAuctionParameters(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     )
         external
         view
@@ -617,10 +458,11 @@ contract MinterDAExpSettlementV3 is
             uint256 basePrice
         )
     {
-        DAExpLib.DAProjectConfig
-            storage _auctionProjectConfig = _auctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
+        DAExpLib.DAProjectConfig storage _auctionProjectConfig = DAExpLib
+            .getDAProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            });
         timestampStart = _auctionProjectConfig.timestampStart;
         priceDecayHalfLifeSeconds = _auctionProjectConfig
             .priceDecayHalfLifeSeconds;
@@ -629,26 +471,25 @@ contract MinterDAExpSettlementV3 is
     }
 
     /**
-     * @notice Checks if the specified `_coreContract` is a valid engine contract.
-     * @dev This function retrieves the cached value of `_coreContract` from
+     * @notice Checks if the specified `coreContract` is a valid engine contract.
+     * @dev This function retrieves the cached value of `coreContract` from
      * the `isEngineCache` mapping. If the cached value is already set, it
-     * returns the cached value. Otherwise, it calls the `getV3CoreIsEngine`
-     * function from the `SplitFundsLib` library to check if `_coreContract`
+     * returns the cached value. Otherwise, it calls the `getV3CoreIsEngineView`
+     * function from the `SplitFundsLib` library to check if `coreContract`
      * is a valid engine contract.
-     * @dev This function will revert if the provided `_coreContract` is not
+     * @dev This function will revert if the provided `coreContract` is not
      * a valid Engine or V3 Flagship contract.
-     * @param _coreContract The address of the contract to check.
-     * @return bool indicating if `_coreContract` is a valid engine contract.
+     * @param coreContract The address of the contract to check.
+     * @return bool indicating if `coreContract` is a valid engine contract.
      */
-    function isEngineView(address _coreContract) external view returns (bool) {
-        SplitFundsLib.IsEngineCache storage isEngineCache = _isEngineCaches[
-            _coreContract
-        ];
+    function isEngineView(address coreContract) external view returns (bool) {
+        SplitFundsLib.IsEngineCache storage isEngineCache = SplitFundsLib
+            .getIsEngineCacheConfig(coreContract);
         if (isEngineCache.isCached) {
             return isEngineCache.isEngine;
         } else {
-            // @dev this calls the non-modifying variant of getV3CoreIsEngine
-            return SplitFundsLib.getV3CoreIsEngineView(_coreContract);
+            // @dev this calls the non-state-modifying variant of isEngine
+            return SplitFundsLib.getV3CoreIsEngineView(coreContract);
         }
     }
 
@@ -659,21 +500,22 @@ contract MinterDAExpSettlementV3 is
      * intentional, as it only enables gas optimization of mints after a
      * project's maximum invocations has been reached. A false negative will
      * only result in a gas cost increase, since the core contract will still
-     * enforce a maxInvocation check during minting. A false positive is not
-     * possible because the V3 core contract only allows maximum invocations
-     * to be reduced, not increased. Based on this rationale, we intentionally
+     * enforce a maxInvocation check during minting. A false positive may be possible
+     * if function `manuallyLimitProjectMaxInvocations` has been invoked, resulting in
+     * `localMaxInvocations` < `coreContractMaxInvocations`. Based on this rationale, we intentionally
      * do not do input validation in this method as to whether or not the input
-     * @param `_projectId` is an existing project ID.
-     * @param `_coreContract` is an existing core contract address.
+     * @param projectId is an existing project ID.
+     * @param coreContract is an existing core contract address.
      */
     function projectMaxHasBeenInvoked(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     ) external view returns (bool) {
         return
-            MaxInvocationsLib.getMaxHasBeenInvoked(
-                _maxInvocationsProjectConfigMapping[_coreContract][_projectId]
-            );
+            MaxInvocationsLib.getMaxHasBeenInvoked({
+                projectId: projectId,
+                coreContract: coreContract
+            });
     }
 
     /**
@@ -686,65 +528,94 @@ contract MinterDAExpSettlementV3 is
      * @dev A number greater than the core contract's project max invocations
      * will only result in a gas cost increase, since the core contract will
      * still enforce a maxInvocation check during minting. A number less than
-     * the core contract's project max invocations is only possible when the
-     * project's max invocations have not been synced on this minter, since the
+     * the core contract's project max invocations is possible if the artist
+     * has called manuallyLimitProjectMaxInvocations or when the project's max
+     * invocations have not been synced on this minter, since the
      * V3 core contract only allows maximum invocations to be reduced, not
      * increased. When this happens, the minter will enable minting, allowing
      * the core contract to enforce the max invocations check. Based on this
      * rationale, we intentionally do not do input validation in this method as
-     * to whether or not the input `_projectId` is an existing project ID.
-     * @param `_projectId` is an existing project ID.
-     * @param `_coreContract` is an existing core contract address.
+     * to whether or not the input `projectId` is an existing project ID.
+     * @param projectId is an existing project ID.
+     * @param coreContract is an existing core contract address.
      */
     function projectMaxInvocations(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     ) external view returns (uint256) {
         return
-            MaxInvocationsLib.getMaxInvocations(
-                _maxInvocationsProjectConfigMapping[_coreContract][_projectId]
-            );
+            MaxInvocationsLib.getMaxInvocations({
+                projectId: projectId,
+                coreContract: coreContract
+            });
     }
 
     /**
-     * @notice Gets the latest purchase price for project `_projectId`, or 0 if
+     * @notice Gets the latest purchase price for project `projectId`, or 0 if
      * no purchases have been made.
-     * @param _projectId Project ID to get latest purchase price for.
-     * @param _coreContract Contract address of the core contract
+     * @param projectId Project ID to get latest purchase price for.
+     * @param coreContract Contract address of the core contract
+     * @return latestPurchasePrice Latest purchase price
      */
     function getProjectLatestPurchasePrice(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     ) external view returns (uint256 latestPurchasePrice) {
         SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        return _settlementAuctionProjectConfig.latestPurchasePrice;
+            storage settlementAuctionProjectConfig = SettlementExpLib
+                .getSettlementAuctionProjectConfig({
+                    projectId: projectId,
+                    coreContract: coreContract
+                });
+        return settlementAuctionProjectConfig.latestPurchasePrice;
     }
 
     /**
-     * @notice Gets the number of settleable invocations for project `_projectId`.
-     * @param _projectId Project ID to get number of settleable invocations for.
-     * @param _coreContract Contract address of the core contract
+     * @notice Gets the number of settleable invocations for project `projectId`.
+     * @param projectId Project ID to get number of settleable invocations for.
+     * @param coreContract Contract address of the core contract
+     * @return numSettleableInvocations Number of settleable invocations
      */
     function getNumSettleableInvocations(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     ) external view returns (uint256 numSettleableInvocations) {
         SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        return _settlementAuctionProjectConfig.numSettleableInvocations;
+            storage settlementAuctionProjectConfig = SettlementExpLib
+                .getSettlementAuctionProjectConfig({
+                    projectId: projectId,
+                    coreContract: coreContract
+                });
+        return settlementAuctionProjectConfig.numSettleableInvocations;
+    }
+
+    /**
+     * @notice Gets the balance of ETH, in wei, currently held by the minter
+     * for project `projectId`. This value is non-zero if not all purchasers
+     * have reclaimed their excess settlement funds, or if an artist/admin has
+     * not yet withdrawn their revenues.
+     * @param projectId Project ID to get balance for.
+     * @param coreContract Contract address of the core contract
+     */
+    function getProjectBalance(
+        uint256 projectId,
+        address coreContract
+    ) external view returns (uint256 projectBalance) {
+        SettlementExpLib.SettlementAuctionProjectConfig
+            storage settlementAuctionProjectConfig = SettlementExpLib
+                .getSettlementAuctionProjectConfig({
+                    projectId: projectId,
+                    coreContract: coreContract
+                });
+        return settlementAuctionProjectConfig.projectBalance;
     }
 
     /**
      * @notice Gets if price of token is configured, price of minting a
-     * token on project `_projectId`, and currency symbol and address to be
+     * token on project `projectId`, and currency symbol and address to be
      * used as payment. Supersedes any core contract price information.
-     * @param _projectId Project ID to get price information for
-     * @param _coreContract Contract address of the core contract
+     * @param projectId Project ID to get price information for
+     * @param coreContract Contract address of the core contract
      * @return isConfigured true only if token price has been configured on
      * this minter
      * @return tokenPriceInWei current price of token on this minter - invalid
@@ -755,8 +626,8 @@ contract MinterDAExpSettlementV3 is
      * this minter. This minter always returns null address, reserved for ether
      */
     function getPriceInfo(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     )
         external
         view
@@ -767,18 +638,11 @@ contract MinterDAExpSettlementV3 is
             address currencyAddress
         )
     {
-        SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        MaxInvocationsLib.MaxInvocationsProjectConfig
-            storage _maxInvocationsProjectConfig = _maxInvocationsProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        DAExpLib.DAProjectConfig
-            storage auctionProjectConfig = _auctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
+        DAExpLib.DAProjectConfig storage auctionProjectConfig = DAExpLib
+            .getDAProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            });
 
         // take action based on configured state
         isConfigured = (auctionProjectConfig.startPrice > 0);
@@ -797,11 +661,8 @@ contract MinterDAExpSettlementV3 is
             // function, and we prefer to use the extra gas to appropriately
             // correct for the case of a stale minter max invocation state.
             tokenPriceInWei = SettlementExpLib.getPriceSafe({
-                _projectId: _projectId,
-                _coreContract: _coreContract,
-                _settlementAuctionProjectConfig: _settlementAuctionProjectConfig,
-                _maxInvocationsProjectConfig: _maxInvocationsProjectConfig,
-                _DAProjectConfig: auctionProjectConfig
+                projectId: projectId,
+                coreContract: coreContract
             });
         }
         currencySymbol = "ETH";
@@ -809,45 +670,38 @@ contract MinterDAExpSettlementV3 is
     }
 
     /**
-     * @notice Gets the current excess settlement funds on project `_projectId`
-     * for address `_walletAddress`. The returned value is expected to change
+     * @notice Gets the current excess settlement funds on project `projectId`
+     * for address `walletAddress`. The returned value is expected to change
      * throughtout an auction, since the latest purchase price is used when
      * determining excess settlement funds.
      * A user may claim excess settlement funds by calling the function
      * `reclaimProjectExcessSettlementFunds(_projectId)`.
-     * @param _projectId Project ID to query.
-     * @param _walletAddress Account address for which the excess posted funds
+     * @param projectId Project ID to query.
+     * @param coreContract Contract address of the core contract
+     * @param walletAddress Account address for which the excess posted funds
      * is being queried.
      * @return excessSettlementFundsInWei Amount of excess settlement funds, in
      * wei
      */
     function getProjectExcessSettlementFunds(
-        uint256 _projectId,
-        address _coreContract,
-        address _walletAddress
+        uint256 projectId,
+        address coreContract,
+        address walletAddress
     ) external view returns (uint256 excessSettlementFundsInWei) {
         // input validation
-        require(_walletAddress != address(0), "No zero address");
-
-        SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        SettlementExpLib.Receipt storage _receipt = _receiptsMapping[
-            _walletAddress
-        ][_coreContract][_projectId];
+        require(walletAddress != address(0), "No zero address");
 
         (excessSettlementFundsInWei, ) = SettlementExpLib
             .getProjectExcessSettlementFunds({
-                _settlementAuctionProjectConfig: _settlementAuctionProjectConfig,
-                _receipt: _receipt
+                projectId: projectId,
+                coreContract: coreContract,
+                walletAddress: walletAddress
             });
-        return excessSettlementFundsInWei;
     }
 
     /**
      * @notice Reclaims the sender's payment above current settled price for
-     * project `_projectId` on core contract `_coreContract`.
+     * project `projectId` on core contract `coreContract`.
      * The current settled price is the the price paid for the most recently
      * purchased token, or the base price if the artist has withdrawn revenues
      * after the auction reached base price.
@@ -855,79 +709,55 @@ contract MinterDAExpSettlementV3 is
      * called after auction has sold out above base price or after the auction
      * has been purchased at base price. This minimizes the amount of gas
      * required to send all excess settlement funds to the sender.
-     * Sends excess settlement funds to address `_to`.
-     * @param _to Address to send excess settlement funds to.
-     * @param _projectId Project ID to reclaim excess settlement funds on.
-     * @param _coreContract Contract address of the core contract
+     * Sends excess settlement funds to address `to`.
+     * @param to Address to send excess settlement funds to.
+     * @param projectId Project ID to reclaim excess settlement funds on.
+     * @param coreContract Contract address of the core contract
      */
     function reclaimProjectExcessSettlementFundsTo(
-        address payable _to,
-        uint256 _projectId,
-        address _coreContract
+        address payable to,
+        uint256 projectId,
+        address coreContract
     ) public nonReentrant {
-        require(_to != address(0), "No claiming to the zero address");
-
-        SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        SettlementExpLib.Receipt storage _receipt = _receiptsMapping[
-            msg.sender
-        ][_coreContract][_projectId];
+        require(to != address(0), "No claiming to the zero address");
 
-        (
-            uint256 excessSettlementFunds,
-            uint256 requiredAmountPosted
-        ) = SettlementExpLib.getProjectExcessSettlementFunds({
-                _settlementAuctionProjectConfig: _settlementAuctionProjectConfig,
-                _receipt: _receipt
-            });
-        uint232 newNetPosted = requiredAmountPosted.toUint232();
-        _receipt.netPosted = newNetPosted;
-
-        emit ReceiptUpdated({
-            _purchaser: msg.sender,
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _numPurchased: _receipt.numPurchased,
-            _netPosted: newNetPosted
+        SettlementExpLib.reclaimProjectExcessSettlementFundsTo({
+            to: to,
+            projectId: projectId,
+            coreContract: coreContract,
+            purchaserAddress: msg.sender
         });
-
-        // INTERACTIONS
-        bool success_;
-        (success_, ) = _to.call{value: excessSettlementFunds}("");
-        require(success_, "Reclaiming failed");
     }
 
     /**
      * @notice Reclaims the sender's payment above current settled price for
-     * projects in `_projectIds`. The current settled price is the the price
+     * projects in `projectIds`. The current settled price is the the price
      * paid for the most recently purchased token, or the base price if the
      * artist has withdrawn revenues after the auction reached base price.
      * This function is callable at any point, but is expected to typically be
      * called after auction has sold out above base price or after the auction
      * has been purchased at base price. This minimizes the amount of gas
      * required to send all excess settlement funds to the sender.
-     * Sends total of all excess settlement funds to `_to` in a single
+     * Sends total of all excess settlement funds to `to` in a single
      * chunk. Entire transaction reverts if any excess settlement calculation
      * fails.
-     * @param _to Address to send excess settlement funds to.
-     * @param _projectIds Array of project IDs to reclaim excess settlement
+     * @param to Address to send excess settlement funds to.
+     * @param projectIds Array of project IDs to reclaim excess settlement
      * funds on.
-     * @param _coreContracts Array of core contract addresses for the given
-     * projects. Must be in the same order as `_projectIds` (aligned by index).
+     * @param coreContracts Array of core contract addresses for the given
+     * projects. Must be in the same order as `projectIds` (aligned by index).
      */
     function reclaimProjectsExcessSettlementFundsTo(
-        address payable _to,
-        uint256[] calldata _projectIds,
-        address[] calldata _coreContracts
+        address payable to,
+        uint256[] calldata projectIds,
+        address[] calldata coreContracts
     ) public nonReentrant {
         // CHECKS
         // input validation
-        require(_to != address(0), "No claiming to the zero address");
-        uint256 projectIdsLength = _projectIds.length;
+        require(to != address(0), "No claiming to the zero address");
+        uint256 projectIdsLength = projectIds.length;
         require(
-            projectIdsLength == _coreContracts.length,
+            projectIdsLength == coreContracts.length,
             "Array lengths must match"
         );
         // EFFECTS
@@ -935,37 +765,13 @@ contract MinterDAExpSettlementV3 is
         // the receipt in storage
         uint256 excessSettlementFunds;
         for (uint256 i; i < projectIdsLength; ) {
-            uint256 projectId = _projectIds[i];
-            address coreContract = _coreContracts[i];
-
-            SettlementExpLib.SettlementAuctionProjectConfig
-                storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                    coreContract
-                ][projectId];
-            SettlementExpLib.Receipt storage _receipt = _receiptsMapping[
-                msg.sender
-            ][coreContract][projectId];
-
-            (
-                uint256 excessSettlementFundsForProject,
-                uint256 requiredAmountPosted
-            ) = SettlementExpLib.getProjectExcessSettlementFunds({
-                    _settlementAuctionProjectConfig: _settlementAuctionProjectConfig,
-                    _receipt: _receipt
-                });
-            uint232 newNetPosted = requiredAmountPosted.toUint232();
-            _receipt.netPosted = newNetPosted;
-
-            excessSettlementFunds += excessSettlementFundsForProject;
-
-            // emit event indicating new receipt state
-            emit ReceiptUpdated({
-                _purchaser: msg.sender,
-                _projectId: projectId,
-                _coreContract: coreContract,
-                _numPurchased: _receipt.numPurchased,
-                _netPosted: newNetPosted
+            SettlementExpLib.reclaimProjectExcessSettlementFundsTo({
+                to: to,
+                projectId: projectIds[i],
+                coreContract: coreContracts[i],
+                purchaserAddress: msg.sender
             });
+
             // gas efficiently increment i
             // won't overflow due to for loop, as well as gas limts
             unchecked {
@@ -977,68 +783,35 @@ contract MinterDAExpSettlementV3 is
         // send excess settlement funds in a single chunk for all
         // projects
         bool success_;
-        (success_, ) = _to.call{value: excessSettlementFunds}("");
+        (success_, ) = to.call{value: excessSettlementFunds}("");
         require(success_, "Reclaiming failed");
     }
 
     /**
-     * @notice This function is intentionally not implemented for this version
-     * of the minter. Due to potential for unintended consequences, the
-     * function `manuallyLimitProjectMaxInvocations` should be used to manually
-     * and explicitly limit the maximum invocations for a project to a value
-     * other than the core contract's maximum invocations for a project.
-     * @param _coreContract Core contract address for the given project.
-     * @param _projectId Project ID to set the maximum invocations for.
-     */
-    function syncProjectMaxInvocationsToCore(
-        uint256 _projectId,
-        address _coreContract
-    ) public view {
-        AuthLib.onlyArtist({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender
-        });
-        revert("Not implemented");
-    }
-
-    /**
-     * @notice Purchases a token from project `_projectId` and sets
-     * the token's owner to `_to`.
-     * @param _to Address to be the new token's owner.
-     * @param _projectId Project ID to mint a token on.
-     * @param _coreContract Core contract address for the given project.
+     * @notice Purchases a token from project `projectId` and sets
+     * the token's owner to `to`.
+     * @param to Address to be the new token's owner.
+     * @param projectId Project ID to mint a token on.
+     * @param coreContract Core contract address for the given project.
      * @return tokenId Token ID of minted token
      */
     function purchaseTo(
-        address _to,
-        uint256 _projectId,
-        address _coreContract
+        address to,
+        uint256 projectId,
+        address coreContract
     ) public payable nonReentrant returns (uint256 tokenId) {
         // CHECKS
-        SettlementExpLib.SettlementAuctionProjectConfig
-            storage _settlementAuctionProjectConfig = _settlementAuctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        MaxInvocationsLib.MaxInvocationsProjectConfig
-            storage _maxInvocationsProjectConfig = _maxInvocationsProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        DAExpLib.DAProjectConfig
-            storage _auctionProjectConfig = _auctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-
+        // pre-mint MaxInvocationsLib checks
         // Note that `maxHasBeenInvoked` is only checked here to reduce gas
         // consumption after a project has been fully minted.
-        // `_maxInvocationsProjectConfig.maxHasBeenInvoked` is locally cached to reduce
+        // `maxInvocationsProjectConfig.maxHasBeenInvoked` is locally cached to reduce
         // gas consumption, but if not in sync with the core contract's value,
         // the core contract also enforces its own max invocation check during
         // minting.
-        require(
-            !_maxInvocationsProjectConfig.maxHasBeenInvoked,
-            "Max invocations reached"
-        );
+        MaxInvocationsLib.preMintChecks({
+            projectId: projectId,
+            coreContract: coreContract
+        });
 
         // _getPriceUnsafe reverts if auction has not yet started or auction is
         // unconfigured, and auction has not sold out or revenues have not been
@@ -1050,77 +823,64 @@ contract MinterDAExpSettlementV3 is
         // call later on in this function, when the core contract's max
         // invocation check fails.
         uint256 currentPriceInWei = SettlementExpLib.getPriceUnsafe({
-            _settlementAuctionProjectConfig: _settlementAuctionProjectConfig,
-            _maxInvocationsProjectConfig: _maxInvocationsProjectConfig,
-            _DAProjectConfig: _auctionProjectConfig
+            projectId: projectId,
+            coreContract: coreContract,
+            maxHasBeenInvoked: false // always false due to MaxInvocationsLib.preMintChecks
         });
 
         // EFFECTS
-        // update the purchaser's receipt and require sufficient net payment
-        SettlementExpLib.Receipt storage receipt = _receiptsMapping[msg.sender][
-            _coreContract
-        ][_projectId];
-
-        (uint232 netPosted, uint24 numPurchased) = SettlementExpLib
-            .validateReceiptEffects(receipt, currentPriceInWei);
-
-        // emit event indicating new receipt state
-        emit ReceiptUpdated({
-            _purchaser: msg.sender,
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _numPurchased: numPurchased,
-            _netPosted: netPosted
+        // update and validate receipts, latest purchase price, overall project
+        // balance, and number of tokens auctioned on this minter
+        SettlementExpLib.preMintEffects({
+            projectId: projectId,
+            coreContract: coreContract,
+            currentPriceInWei: currentPriceInWei,
+            msgValue: msg.value,
+            purchaserAddress: msg.sender
         });
 
-        // update latest purchase price (on this minter) in storage
-        // @dev this is used to enforce monotonically decreasing purchase price
-        // across multiple auctions
-        _settlementAuctionProjectConfig.latestPurchasePrice = currentPriceInWei
-            .toUint128();
-
-        tokenId = minterFilter.mint_joo({
-            _to: _to,
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender
+        // INTERACTIONS
+        tokenId = _minterFilter.mint_joo({
+            to: to,
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender
         });
 
         // verify token invocation is valid given local minter max invocations,
         // update local maxHasBeenInvoked
-        MaxInvocationsLib.validatePurchaseEffectsInvocations(
-            tokenId,
-            _maxInvocationsProjectConfig
-        );
+        MaxInvocationsLib.validatePurchaseEffectsInvocations({
+            tokenId: tokenId,
+            coreContract: coreContract
+        });
 
-        // INTERACTIONS
-        // @dev this logic is intentionally defined here to avoid a dependency
-        // in SettlementLib on SplitFundsLib, which would increase complexity
-        if (_settlementAuctionProjectConfig.auctionRevenuesCollected) {
-            // if revenues have been collected, split funds immediately.
-            // @dev note that we are guaranteed to be at auction base price,
-            // since we know we didn't sellout prior to this tx.
-            // note that we don't refund msg.sender here, since a separate
-            // settlement mechanism is provided on this minter, unrelated to
-            // msg.value
-            // INTERACTIONS
-            bool isEngine = SplitFundsLib.isEngine(
-                _coreContract,
-                _isEngineCaches[_coreContract]
-            );
-            SplitFundsLib.splitFundsETH({
-                _projectId: _projectId,
-                _pricePerTokenInWei: currentPriceInWei,
-                _coreContract: _coreContract,
-                _isEngine: isEngine
-            });
-        } else {
-            // increment the number of settleable invocations that will be
-            // claimable by the artist and admin once auction is validated.
-            // do not split revenue here since will be claimed at a later time.
-            _settlementAuctionProjectConfig.numSettleableInvocations++;
-        }
+        // distribute payments if revenues have been collected, or increment
+        // number of settleable invocations if revenues have not been collected
+        SettlementExpLib.postMintInteractions({
+            projectId: projectId,
+            coreContract: coreContract,
+            currentPriceInWei: currentPriceInWei
+        });
+    }
 
-        return tokenId;
+    /**
+     * @notice This function is intentionally not implemented for this version
+     * of the minter. Due to potential for unintended consequences, the
+     * function `manuallyLimitProjectMaxInvocations` should be used to manually
+     * and explicitly limit the maximum invocations for a project to a value
+     * other than the core contract's maximum invocations for a project.
+     * @param coreContract Core contract address for the given project.
+     * @param projectId Project ID to set the maximum invocations for.
+     */
+    function syncProjectMaxInvocationsToCore(
+        uint256 projectId,
+        address coreContract
+    ) public view {
+        AuthLib.onlyArtist({
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender
+        });
+        revert("Not implemented");
     }
 }