@artblocks/contracts 1.0.4 → 1.2.0

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

@@ -1,25 +1,27 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
 
-import "../../interfaces/v0.8.x/IDelegationRegistry.sol";
-import "../../interfaces/v0.8.x/ISharedMinterV0.sol";
-import "../../interfaces/v0.8.x/ISharedMinterDAV0.sol";
-import "../../interfaces/v0.8.x/ISharedMinterDALinV0.sol";
-import "../../interfaces/v0.8.x/ISharedMinterHolderV0.sol";
-import "../../interfaces/v0.8.x/IMinterFilterV1.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/TokenHolderLib.sol";
-import "../../libs/v0.8.x/minter-libs/DALinLib.sol";
-import "../../libs/v0.8.x/AuthLib.sol";
-
-import "@openzeppelin-4.7/contracts/utils/math/SafeCast.sol";
-import "@openzeppelin-4.5/contracts/security/ReentrancyGuard.sol";
-import "@openzeppelin-4.5/contracts/utils/structs/EnumerableSet.sol";
-
+// @dev fixed to specific solidity version for clarity and for more clear
+// source code verification purposes.
 pragma solidity 0.8.19;
 
+import {IDelegationRegistry} from "../../interfaces/v0.8.x/IDelegationRegistry.sol";
+import {ISharedMinterDAV0} from "../../interfaces/v0.8.x/ISharedMinterDAV0.sol";
+import {ISharedMinterV0} from "../../interfaces/v0.8.x/ISharedMinterV0.sol";
+import {ISharedMinterDALinV0} from "../../interfaces/v0.8.x/ISharedMinterDALinV0.sol";
+import {ISharedMinterHolderV0} from "../../interfaces/v0.8.x/ISharedMinterHolderV0.sol";
+import {IMinterFilterV1} from "../../interfaces/v0.8.x/IMinterFilterV1.sol";
+
+import {SplitFundsLib} from "../../libs/v0.8.x/minter-libs/SplitFundsLib.sol";
+import {MaxInvocationsLib} from "../../libs/v0.8.x/minter-libs/MaxInvocationsLib.sol";
+import {TokenHolderLib} from "../../libs/v0.8.x/minter-libs/TokenHolderLib.sol";
+import {DALinLib} from "../../libs/v0.8.x/minter-libs/DALinLib.sol";
+import {AuthLib} from "../../libs/v0.8.x/AuthLib.sol";
+
+import {SafeCast} from "@openzeppelin-4.7/contracts/utils/math/SafeCast.sol";
+import {ReentrancyGuard} from "@openzeppelin-4.5/contracts/security/ReentrancyGuard.sol";
+import {EnumerableSet} from "@openzeppelin-4.5/contracts/utils/structs/EnumerableSet.sol";
+
 /**
  * @title Shared, filtered Minter contract that allows tokens to be minted with
  * ETH when purchaser owns an allowlisted ERC-721 NFT. This contract does NOT
@@ -72,6 +74,13 @@ pragma solidity 0.8.19;
  * delegation types include token-level, contract-level (via genArt721CoreAddress), or
  * wallet-level delegation. Contract-level delegations must be configured for the core
  * token contract as returned by the public immutable variable `genArt721CoreAddress`.
+ * ----------------------------------------------------------------------------
+ * @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, such
@@ -96,13 +105,13 @@ contract MinterDALinHolderV5 is
     address public immutable minterFilterAddress;
 
     /// Minter filter this minter may interact with.
-    IMinterFilterV1 private immutable minterFilter;
+    IMinterFilterV1 private immutable _minterFilter;
 
     // Delegation registry address
     address public immutable delegationRegistryAddress;
 
     // Delegation registry address
-    IDelegationRegistry private immutable delegationRegistryContract;
+    IDelegationRegistry private immutable _delegationRegistryContract;
 
     /// minterType for this minter
     string public constant minterType = "MinterDALinHolderV5";
@@ -113,272 +122,187 @@ contract MinterDALinHolderV5 is
     /// Minimum auction length in seconds
     uint256 public minimumAuctionLengthSeconds = 600; // 10 minutes
 
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR SplitFundsLib begin here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    // contractAddress => IsEngineCache
-    mapping(address => SplitFundsLib.IsEngineCache) private _isEngineCaches;
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR SplitFundsLib end here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR DALinLib begin here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    mapping(address => mapping(uint256 => DALinLib.DAProjectConfig))
-        private _auctionProjectConfigMapping;
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR DALinLib 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
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR TokenHolderLib begin here
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    /**
-     * coreContract => projectId => ownedNFTAddress => ownedNFTProjectIds => bool
-     * projects whose holders are allowed to purchase a token on `projectId`
-     */
-    mapping(address => mapping(uint256 => TokenHolderLib.HolderProjectConfig))
-        private _allowedProjectHoldersMapping;
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // STATE VARIABLES FOR TokenHolderLib 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,
-        address _delegationRegistryAddress
+        address minterFilter,
+        address delegationRegistryAddress_
     ) ReentrancyGuard() {
-        minterFilterAddress = _minterFilter;
-        minterFilter = IMinterFilterV1(_minterFilter);
+        minterFilterAddress = minterFilter;
+        _minterFilter = IMinterFilterV1(minterFilter);
 
-        delegationRegistryAddress = _delegationRegistryAddress;
-        delegationRegistryContract = IDelegationRegistry(
-            _delegationRegistryAddress
+        delegationRegistryAddress = delegationRegistryAddress_;
+        _delegationRegistryContract = IDelegationRegistry(
+            delegationRegistryAddress_
+        );
+        emit TokenHolderLib.DelegationRegistryUpdated(
+            delegationRegistryAddress_
+        );
+        emit DALinLib.AuctionMinimumLengthSecondsUpdated(
+            minimumAuctionLengthSeconds
         );
-        emit DelegationRegistryUpdated(_delegationRegistryAddress);
-        emit AuctionMinimumLengthSecondsUpdated(minimumAuctionLengthSeconds);
     }
 
     /**
-     * @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
         });
         MaxInvocationsLib.manuallyLimitProjectMaxInvocations({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _maxInvocations: _maxInvocations,
-            maxInvocationsProjectConfig: _maxInvocationsProjectConfigMapping[
-                _coreContract
-            ][_projectId]
+            projectId: projectId,
+            coreContract: coreContract,
+            maxInvocations: maxInvocations
         });
-
-        emit ProjectMaxInvocationsLimitUpdated(
-            _projectId,
-            _coreContract,
-            _maxInvocations
-        );
     }
 
     /**
-     * @notice Allows holders of NFTs at addresses `_ownedNFTAddresses`,
-     * project IDs `_ownedNFTProjectIds` to mint on project `_projectId`.
-     * `_ownedNFTAddresses` assumed to be aligned with `_ownedNFTProjectIds`.
-     * e.g. Allows holders of project `_ownedNFTProjectIds[0]` on token
-     * contract `_ownedNFTAddresses[0]` to mint `_projectId`.
+     * @notice Allows holders of NFTs at addresses `ownedNFTAddresses`,
+     * project IDs `ownedNFTProjectIds` to mint on project `projectId`.
+     * `ownedNFTAddresses` assumed to be aligned with `ownedNFTProjectIds`.
+     * e.g. Allows holders of project `ownedNFTProjectIds[0]` on token
+     * contract `ownedNFTAddresses[0]` to mint `projectId`.
      * WARNING: Only Art Blocks Core contracts are compatible with holder allowlisting,
      * due to assumptions about tokenId and projectId relationships.
-     * @param _projectId Project ID to enable minting on.
-     * @param _coreContract Core contract address for the given project.
-     * @param _ownedNFTAddresses NFT core addresses of projects to be
-     * allowlisted. Indexes must align with `_ownedNFTProjectIds`.
-     * @param _ownedNFTProjectIds Project IDs on `_ownedNFTAddresses` whose
-     * holders shall be allowlisted to mint project `_projectId`. Indexes must
-     * align with `_ownedNFTAddresses`.
+     * @param projectId Project ID to enable minting on.
+     * @param coreContract Core contract address for the given project.
+     * @param ownedNFTAddresses NFT core addresses of projects to be
+     * allowlisted. Indexes must align with `ownedNFTProjectIds`.
+     * @param ownedNFTProjectIds Project IDs on `ownedNFTAddresses` whose
+     * holders shall be allowlisted to mint project `projectId`. Indexes must
+     * align with `ownedNFTAddresses`.
      */
     function allowHoldersOfProjects(
-        uint256 _projectId,
-        address _coreContract,
-        address[] memory _ownedNFTAddresses,
-        uint256[] memory _ownedNFTProjectIds
+        uint256 projectId,
+        address coreContract,
+        address[] calldata ownedNFTAddresses,
+        uint256[] calldata ownedNFTProjectIds
     ) external {
         AuthLib.onlyArtist({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender
         });
         TokenHolderLib.allowHoldersOfProjects({
-            holderProjectConfig: _allowedProjectHoldersMapping[_coreContract][
-                _projectId
-            ],
-            _ownedNFTAddresses: _ownedNFTAddresses,
-            _ownedNFTProjectIds: _ownedNFTProjectIds
+            projectId: projectId,
+            coreContract: coreContract,
+            ownedNFTAddresses: ownedNFTAddresses,
+            ownedNFTProjectIds: ownedNFTProjectIds
         });
-        // emit approve event
-        emit AllowedHoldersOfProjects(
-            _projectId,
-            _coreContract,
-            _ownedNFTAddresses,
-            _ownedNFTProjectIds
-        );
     }
 
     /**
-     * @notice Removes holders of NFTs at addresses `_ownedNFTAddresses`,
-     * project IDs `_ownedNFTProjectIds` to mint on project `_projectId`. If
+     * @notice Removes holders of NFTs at addresses `ownedNFTAddresses`,
+     * project IDs `ownedNFTProjectIds` to mint on project `projectId`. If
      * other projects owned by a holder are still allowed to mint, holder will
      * maintain ability to purchase.
-     * `_ownedNFTAddresses` assumed to be aligned with `_ownedNFTProjectIds`.
-     * e.g. Removes holders of project `_ownedNFTProjectIds[0]` on token
-     * contract `_ownedNFTAddresses[0]` from mint allowlist of `_projectId`.
-     * @param _projectId Project ID to enable minting on.
-     * @param _coreContract Core contract address for the given project.
-     * @param _ownedNFTAddresses NFT core addresses of projects to be removed
-     * from allowlist. Indexes must align with `_ownedNFTProjectIds`.
-     * @param _ownedNFTProjectIds Project IDs on `_ownedNFTAddresses` whose
-     * holders will be removed from allowlist to mint project `_projectId`.
-     * Indexes must align with `_ownedNFTAddresses`.
+     * `ownedNFTAddresses` assumed to be aligned with `ownedNFTProjectIds`.
+     * e.g. Removes holders of project `ownedNFTProjectIds[0]` on token
+     * contract `ownedNFTAddresses[0]` from mint allowlist of `projectId`.
+     * @param projectId Project ID to enable minting on.
+     * @param coreContract Core contract address for the given project.
+     * @param ownedNFTAddresses NFT core addresses of projects to be removed
+     * from allowlist. Indexes must align with `ownedNFTProjectIds`.
+     * @param ownedNFTProjectIds Project IDs on `ownedNFTAddresses` whose
+     * holders will be removed from allowlist to mint project `projectId`.
+     * Indexes must align with `ownedNFTAddresses`.
      */
     function removeHoldersOfProjects(
-        uint256 _projectId,
-        address _coreContract,
-        address[] memory _ownedNFTAddresses,
-        uint256[] memory _ownedNFTProjectIds
+        uint256 projectId,
+        address coreContract,
+        address[] calldata ownedNFTAddresses,
+        uint256[] calldata ownedNFTProjectIds
     ) external {
         AuthLib.onlyArtist({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender
         });
         // require same length arrays
         TokenHolderLib.removeHoldersOfProjects({
-            holderProjectConfig: _allowedProjectHoldersMapping[_coreContract][
-                _projectId
-            ],
-            _ownedNFTAddresses: _ownedNFTAddresses,
-            _ownedNFTProjectIds: _ownedNFTProjectIds
+            projectId: projectId,
+            coreContract: coreContract,
+            ownedNFTAddresses: ownedNFTAddresses,
+            ownedNFTProjectIds: ownedNFTProjectIds
         });
-        // emit removed event
-        emit RemovedHoldersOfProjects(
-            _projectId,
-            _coreContract,
-            _ownedNFTAddresses,
-            _ownedNFTProjectIds
-        );
     }
 
     /**
-     * @notice Allows holders of NFTs at addresses `_ownedNFTAddressesAdd`,
-     * project IDs `_ownedNFTProjectIdsAdd` to mint on project `_projectId`.
-     * Also removes holders of NFTs at addresses `_ownedNFTAddressesRemove`,
-     * project IDs `_ownedNFTProjectIdsRemove` from minting on project
-     * `_projectId`.
-     * `_ownedNFTAddressesAdd` assumed to be aligned with
-     * `_ownedNFTProjectIdsAdd`.
-     * e.g. Allows holders of project `_ownedNFTProjectIdsAdd[0]` on token
-     * contract `_ownedNFTAddressesAdd[0]` to mint `_projectId`.
-     * `_ownedNFTAddressesRemove` also assumed to be aligned with
-     * `_ownedNFTProjectIdsRemove`.
+     * @notice Allows holders of NFTs at addresses `ownedNFTAddressesAdd`,
+     * project IDs `ownedNFTProjectIdsAdd` to mint on project `projectId`.
+     * Also removes holders of NFTs at addresses `ownedNFTAddressesRemove`,
+     * project IDs `ownedNFTProjectIdsRemove` from minting on project
+     * `projectId`.
+     * `ownedNFTAddressesAdd` assumed to be aligned with
+     * `ownedNFTProjectIdsAdd`.
+     * e.g. Allows holders of project `ownedNFTProjectIdsAdd[0]` on token
+     * contract `ownedNFTAddressesAdd[0]` to mint `projectId`.
+     * `ownedNFTAddressesRemove` also assumed to be aligned with
+     * `ownedNFTProjectIdsRemove`.
      * WARNING: Only Art Blocks Core contracts are compatible with holder allowlisting,
      * due to assumptions about tokenId and projectId relationships.
-     * @param _projectId Project ID to enable minting on.
-     * @param _coreContract Core contract address for the given project.
-     * @param _ownedNFTAddressesAdd NFT core addresses of projects to be
-     * allowlisted. Indexes must align with `_ownedNFTProjectIdsAdd`.
-     * @param _ownedNFTProjectIdsAdd Project IDs on `_ownedNFTAddressesAdd`
-     * whose holders shall be allowlisted to mint project `_projectId`. Indexes
-     * must align with `_ownedNFTAddressesAdd`.
-     * @param _ownedNFTAddressesRemove NFT core addresses of projects to be
+     * @param projectId Project ID to enable minting on.
+     * @param coreContract Core contract address for the given project.
+     * @param ownedNFTAddressesAdd NFT core addresses of projects to be
+     * allowlisted. Indexes must align with `ownedNFTProjectIdsAdd`.
+     * @param ownedNFTProjectIdsAdd Project IDs on `ownedNFTAddressesAdd`
+     * whose holders shall be allowlisted to mint project `projectId`. Indexes
+     * must align with `ownedNFTAddressesAdd`.
+     * @param ownedNFTAddressesRemove NFT core addresses of projects to be
      * removed from allowlist. Indexes must align with
-     * `_ownedNFTProjectIdsRemove`.
-     * @param _ownedNFTProjectIdsRemove Project IDs on
-     * `_ownedNFTAddressesRemove` whose holders will be removed from allowlist
-     * to mint project `_projectId`. Indexes must align with
-     * `_ownedNFTAddressesRemove`.
+     * `ownedNFTProjectIdsRemove`.
+     * @param ownedNFTProjectIdsRemove Project IDs on
+     * `ownedNFTAddressesRemove` whose holders will be removed from allowlist
+     * to mint project `projectId`. Indexes must align with
+     * `ownedNFTAddressesRemove`.
      * @dev if a project is included in both add and remove arrays, it will be
      * removed.
      */
     function allowAndRemoveHoldersOfProjects(
-        uint256 _projectId,
-        address _coreContract,
-        address[] memory _ownedNFTAddressesAdd,
-        uint256[] memory _ownedNFTProjectIdsAdd,
-        address[] memory _ownedNFTAddressesRemove,
-        uint256[] memory _ownedNFTProjectIdsRemove
+        uint256 projectId,
+        address coreContract,
+        address[] calldata ownedNFTAddressesAdd,
+        uint256[] calldata ownedNFTProjectIdsAdd,
+        address[] calldata ownedNFTAddressesRemove,
+        uint256[] calldata ownedNFTProjectIdsRemove
     ) external {
         AuthLib.onlyArtist({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender
         });
         TokenHolderLib.allowAndRemoveHoldersOfProjects({
-            holderProjectConfig: _allowedProjectHoldersMapping[_coreContract][
-                _projectId
-            ],
-            _ownedNFTAddressesAdd: _ownedNFTAddressesAdd,
-            _ownedNFTProjectIdsAdd: _ownedNFTProjectIdsAdd,
-            _ownedNFTAddressesRemove: _ownedNFTAddressesRemove,
-            _ownedNFTProjectIdsRemove: _ownedNFTProjectIdsRemove
+            projectId: projectId,
+            coreContract: coreContract,
+            ownedNFTAddressesAdd: ownedNFTAddressesAdd,
+            ownedNFTProjectIdsAdd: ownedNFTProjectIdsAdd,
+            ownedNFTAddressesRemove: ownedNFTAddressesRemove,
+            ownedNFTProjectIdsRemove: ownedNFTProjectIdsRemove
         });
-
-        // emit events
-        emit AllowedHoldersOfProjects(
-            _projectId,
-            _coreContract,
-            _ownedNFTAddressesAdd,
-            _ownedNFTProjectIdsAdd
-        );
-        emit RemovedHoldersOfProjects(
-            _projectId,
-            _coreContract,
-            _ownedNFTAddressesRemove,
-            _ownedNFTProjectIdsRemove
-        );
     }
 
     /**
-     * @notice Sets auction details for project `_projectId`.
+     * @notice Sets auction details for project `projectId`.
      * Requires one of the following:
      * - The auction is unconfigured
      * - The auction has not yet started
@@ -387,214 +311,209 @@ contract MinterDALinHolderV5 is
      * max invocations effectively grants the artist the ability to set a new
      * auction at any point, since minter-local max invocations can be set by
      * the artist.
-     * @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 _auctionTimestampEnd Timestamp at which to end the auction.
-     * @param _startPrice Price at which to start the auction, in Wei.
-     * @param _basePrice Resting price of the auction, in Wei.
+     * @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 auctionTimestampEnd Timestamp at which to end the auction.
+     * @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`.
      */
     function setAuctionDetails(
-        uint256 _projectId,
-        address _coreContract,
-        uint40 _auctionTimestampStart,
-        uint40 _auctionTimestampEnd,
-        uint256 _startPrice,
-        uint256 _basePrice
+        uint256 projectId,
+        address coreContract,
+        uint40 auctionTimestampStart,
+        uint40 auctionTimestampEnd,
+        uint256 startPrice,
+        uint256 basePrice
     ) external {
         AuthLib.onlyArtist({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender
         });
         // CHECKS
-        DALinLib.DAProjectConfig
-            storage _auctionProjectConfig = _auctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        MaxInvocationsLib.MaxInvocationsProjectConfig
-            storage _maxInvocationsProjectConfig = _maxInvocationsProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-
         require(
-            _auctionTimestampEnd >=
-                _auctionTimestampStart + minimumAuctionLengthSeconds,
+            auctionTimestampEnd >=
+                auctionTimestampStart + minimumAuctionLengthSeconds,
             "Auction length must be at least minimumAuctionLengthSeconds"
         );
 
         // EFFECTS
-        bool maxHasBeenInvoked = MaxInvocationsLib.getMaxHasBeenInvoked(
-            _maxInvocationsProjectConfig
-        );
-        DALinLib.setAuctionDetailsLin({
-            _DAProjectConfig: _auctionProjectConfig,
-            _auctionTimestampStart: _auctionTimestampStart,
-            _auctionTimestampEnd: _auctionTimestampEnd,
-            _startPrice: _startPrice.toUint88(),
-            _basePrice: _basePrice.toUint88(),
-            _allowReconfigureAfterStart: maxHasBeenInvoked
+        bool maxHasBeenInvoked = MaxInvocationsLib.getMaxHasBeenInvoked({
+            projectId: projectId,
+            coreContract: coreContract
         });
-
-        emit SetAuctionDetailsLin({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _auctionTimestampStart: _auctionTimestampStart,
-            _auctionTimestampEnd: _auctionTimestampEnd,
-            _startPrice: _startPrice,
-            _basePrice: _basePrice
+        DALinLib.setAuctionDetailsLin({
+            projectId: projectId,
+            coreContract: coreContract,
+            auctionTimestampStart: auctionTimestampStart,
+            auctionTimestampEnd: auctionTimestampEnd,
+            startPrice: startPrice.toUint88(),
+            basePrice: basePrice.toUint88(),
+            allowReconfigureAfterStart: maxHasBeenInvoked
         });
 
         // sync local max invocations if not initially populated
         // @dev if local max invocations and maxHasBeenInvoked are both
         // initial values, we know they have not been populated.
         if (
-            MaxInvocationsLib.maxInvocationsIsUnconfigured(
-                _maxInvocationsProjectConfig
-            )
+            MaxInvocationsLib.maxInvocationsIsUnconfigured({
+                projectId: projectId,
+                coreContract: coreContract
+            })
         ) {
-            syncProjectMaxInvocationsToCore(_projectId, _coreContract);
+            MaxInvocationsLib.syncProjectMaxInvocationsToCore({
+                projectId: projectId,
+                coreContract: coreContract
+            });
         }
     }
 
     /**
-     * @notice Sets minimum auction length to `_minimumAuctionLengthSeconds`
+     * @notice Sets minimum auction length to `minimumAuctionLengthSeconds`
      * for all projects.
-     * @param _minimumAuctionLengthSeconds Minimum auction length in seconds.
+     * @param minimumAuctionLengthSeconds_ Minimum auction length in seconds.
      */
     function setMinimumAuctionLengthSeconds(
-        uint256 _minimumAuctionLengthSeconds
+        uint256 minimumAuctionLengthSeconds_
     ) external {
         AuthLib.onlyMinterFilterAdminACL({
-            _minterFilterAddress: minterFilterAddress,
-            _sender: msg.sender,
-            _contract: address(this),
-            _selector: this.setMinimumAuctionLengthSeconds.selector
+            minterFilterAddress: minterFilterAddress,
+            sender: msg.sender,
+            contract_: address(this),
+            selector: this.setMinimumAuctionLengthSeconds.selector
         });
-        minimumAuctionLengthSeconds = _minimumAuctionLengthSeconds;
-        emit AuctionMinimumLengthSecondsUpdated(_minimumAuctionLengthSeconds);
+        minimumAuctionLengthSeconds = minimumAuctionLengthSeconds_;
+        emit DALinLib.AuctionMinimumLengthSecondsUpdated(
+            minimumAuctionLengthSeconds_
+        );
     }
 
     /**
-     * @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 _coreContract Core contract address for the given project.
+     * @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
         });
 
-        delete _auctionProjectConfigMapping[_coreContract][_projectId];
-
-        emit ResetAuctionDetails(_projectId, _coreContract);
+        DALinLib.resetAuctionDetails({
+            projectId: projectId,
+            coreContract: coreContract
+        });
     }
 
     /**
-     * @notice Purchases a token from project `_projectId`.
+     * @notice Purchases a token from project `projectId`.
      * Note: Collectors should not send excessive value with their purchase
      * transaction, because the artist has the ability to change the auction
      * details at any time, including the price.
-     * @param _projectId Project ID to mint a token on.
-     * @param _coreContract Core contract address for the given project.
-     * @param _ownedNFTAddress ERC-721 NFT holding the project token owned by
+     * @param projectId Project ID to mint a token on.
+     * @param coreContract Core contract address for the given project.
+     * @param ownedNFTAddress ERC-721 NFT holding the project token owned by
      * msg.sender being used to claim right to purchase.
-     * @param _ownedNFTTokenId ERC-721 NFT token ID owned by msg.sender being used
+     * @param ownedNFTTokenId ERC-721 NFT token ID owned by msg.sender being used
      * to claim right to purchase.
      * @return tokenId Token ID of minted token
      */
     function purchase(
-        uint256 _projectId,
-        address _coreContract,
-        address _ownedNFTAddress,
-        uint256 _ownedNFTTokenId
+        uint256 projectId,
+        address coreContract,
+        address ownedNFTAddress,
+        uint256 ownedNFTTokenId
     ) external payable returns (uint256 tokenId) {
         tokenId = purchaseTo({
-            _to: msg.sender,
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _ownedNFTAddress: _ownedNFTAddress,
-            _ownedNFTTokenId: _ownedNFTTokenId,
-            _vault: address(0)
+            to: msg.sender,
+            projectId: projectId,
+            coreContract: coreContract,
+            ownedNFTAddress: ownedNFTAddress,
+            ownedNFTTokenId: ownedNFTTokenId,
+            vault: address(0)
         });
 
         return tokenId;
     }
 
     /**
-     * @notice Purchases a token from project `_projectId` and sets
-     * the token's owner to `_to`.
+     * @notice Purchases a token from project `projectId` and sets
+     * the token's owner to `to`.
      * Note: Collectors should not send excessive value with their purchase
      * transaction, because the artist has the ability to change the auction
      * details at any time, including the price.
-     * @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.
-     * @param _ownedNFTAddress ERC-721 NFT holding the project token owned by
+     * @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.
+     * @param ownedNFTAddress ERC-721 NFT holding the project token owned by
      * msg.sender being used to claim right to purchase.
-     * @param _ownedNFTTokenId ERC-721 NFT token ID owned by msg.sender being used
+     * @param ownedNFTTokenId ERC-721 NFT token ID owned by msg.sender being used
      * to claim right to purchase.
      * @return tokenId Token ID of minted token
      */
     function purchaseTo(
-        address _to,
-        uint256 _projectId,
-        address _coreContract,
-        address _ownedNFTAddress,
-        uint256 _ownedNFTTokenId
+        address to,
+        uint256 projectId,
+        address coreContract,
+        address ownedNFTAddress,
+        uint256 ownedNFTTokenId
     ) external payable returns (uint256 tokenId) {
         return
             purchaseTo({
-                _to: _to,
-                _projectId: _projectId,
-                _coreContract: _coreContract,
-                _ownedNFTAddress: _ownedNFTAddress,
-                _ownedNFTTokenId: _ownedNFTTokenId,
-                _vault: address(0)
+                to: to,
+                projectId: projectId,
+                coreContract: coreContract,
+                ownedNFTAddress: ownedNFTAddress,
+                ownedNFTTokenId: ownedNFTTokenId,
+                vault: address(0)
             });
     }
 
     // public getter functions
     /**
      * @notice Gets the maximum invocations project configuration.
-     * @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.
+     * @param coreContract The address of the core contract.
      * @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 timestampEnd The end timestamp for the auction.
      * @return startPrice The starting price of the auction.
      * @return basePrice The base price of the auction.
      */
     function projectAuctionParameters(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     )
         external
         view
@@ -605,37 +524,37 @@ contract MinterDALinHolderV5 is
             uint256 basePrice
         )
     {
-        DALinLib.DAProjectConfig
-            storage _auctionProjectConfig = _auctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-        timestampStart = _auctionProjectConfig.timestampStart;
-        timestampEnd = _auctionProjectConfig.timestampEnd;
-        startPrice = _auctionProjectConfig.startPrice;
-        basePrice = _auctionProjectConfig.basePrice;
+        DALinLib.DAProjectConfig storage auctionProjectConfig = DALinLib
+            .getDAProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            });
+        timestampStart = auctionProjectConfig.timestampStart;
+        timestampEnd = auctionProjectConfig.timestampEnd;
+        startPrice = auctionProjectConfig.startPrice;
+        basePrice = auctionProjectConfig.basePrice;
     }
 
     /**
-     * @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);
         }
     }
 
@@ -650,17 +569,18 @@ contract MinterDALinHolderV5 is
      * possible because the V3 core contract only allows maximum invocations
      * to be reduced, not increased. 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
+            });
     }
 
     /**
@@ -679,26 +599,27 @@ contract MinterDALinHolderV5 is
      * 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 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
@@ -709,8 +630,8 @@ contract MinterDALinHolderV5 is
      * this minter. This minter always returns null address, reserved for ether
      */
     function getPriceInfo(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     )
         external
         view
@@ -721,10 +642,11 @@ contract MinterDALinHolderV5 is
             address currencyAddress
         )
     {
-        DALinLib.DAProjectConfig
-            storage auctionProjectConfig = _auctionProjectConfigMapping[
-                _coreContract
-            ][_projectId];
+        DALinLib.DAProjectConfig storage auctionProjectConfig = DALinLib
+            .getDAProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            });
         isConfigured = (auctionProjectConfig.startPrice > 0);
         if (!isConfigured) {
             // In the case of unconfigured auction, return price of zero when
@@ -736,7 +658,10 @@ contract MinterDALinHolderV5 is
             // before auction starts.
             tokenPriceInWei = auctionProjectConfig.startPrice;
         } else {
-            tokenPriceInWei = DALinLib.getPriceLin(auctionProjectConfig);
+            tokenPriceInWei = DALinLib.getPriceLin({
+                projectId: projectId,
+                coreContract: coreContract
+            });
         }
         currencySymbol = "ETH";
         currencyAddress = address(0);
@@ -746,141 +671,126 @@ contract MinterDALinHolderV5 is
      * @notice Checks if a specific NFT owner is allowed in a given project.
      * @dev This function retrieves the allowance status of an NFT owner
      * within a specific project from the allowedProjectHoldersMapping.
-     * @param _projectId The ID of the project to check.
-     * @param _coreContract Core contract address for the given project.
-     * @param _ownedNFTAddress The address of the owned NFT contract.
-     * @param _ownedNFTProjectId The ID of the owned NFT project.
+     * @param projectId The ID of the project to check.
+     * @param coreContract Core contract address for the given project.
+     * @param ownedNFTAddress The address of the owned NFT contract.
+     * @param ownedNFTProjectId The ID of the owned NFT project.
      * @return bool True if the NFT owner is allowed in the given project, False otherwise.
      */
     function allowedProjectHolders(
-        uint256 _projectId,
-        address _coreContract,
-        address _ownedNFTAddress,
-        uint256 _ownedNFTProjectId
+        uint256 projectId,
+        address coreContract,
+        address ownedNFTAddress,
+        uint256 ownedNFTProjectId
     ) external view returns (bool) {
         return
-            _allowedProjectHoldersMapping[_coreContract][_projectId]
-                .allowedProjectHolders[_ownedNFTAddress][_ownedNFTProjectId];
+            TokenHolderLib
+                .getHolderProjectConfig({
+                    projectId: projectId,
+                    coreContract: coreContract
+                })
+                .allowedProjectHolders[ownedNFTAddress][ownedNFTProjectId];
     }
 
     /**
-     * @notice Returns if token is an allowlisted NFT for project `_projectId`.
-     * @param _projectId Project ID to be checked.
-     * @param _coreContract Core contract address for the given project.
-     * @param _ownedNFTAddress ERC-721 NFT token address to be checked.
-     * @param _ownedNFTTokenId ERC-721 NFT token ID to be checked.
+     * @notice Returns if token is an allowlisted NFT for project `projectId`.
+     * @param projectId Project ID to be checked.
+     * @param coreContract Core contract address for the given project.
+     * @param ownedNFTAddress ERC-721 NFT token address to be checked.
+     * @param ownedNFTTokenId ERC-721 NFT token ID to be checked.
      * @return bool Token is allowlisted
      * @dev does not check if token has been used to purchase
      * @dev assumes project ID can be derived from tokenId / 1_000_000
      */
     function isAllowlistedNFT(
-        uint256 _projectId,
-        address _coreContract,
-        address _ownedNFTAddress,
-        uint256 _ownedNFTTokenId
+        uint256 projectId,
+        address coreContract,
+        address ownedNFTAddress,
+        uint256 ownedNFTTokenId
     ) external view returns (bool) {
         return
             TokenHolderLib.isAllowlistedNFT({
-                holderProjectConfig: _allowedProjectHoldersMapping[
-                    _coreContract
-                ][_projectId],
-                _ownedNFTAddress: _ownedNFTAddress,
-                _ownedNFTTokenId: _ownedNFTTokenId
+                projectId: projectId,
+                coreContract: coreContract,
+                ownedNFTAddress: ownedNFTAddress,
+                ownedNFTTokenId: ownedNFTTokenId
             });
     }
 
     /**
-     * @notice Syncs local maximum invocations of project `_projectId` based on
+     * @notice Syncs local maximum invocations of project `projectId` based on
      * the value currently defined in the core contract.
-     * @param _projectId Project ID to set the maximum invocations for.
-     * @param _coreContract Core contract address for the given project.
+     * @param projectId Project ID to set the maximum invocations for.
+     * @param coreContract Core contract address for the given project.
      * @dev this enables gas reduction after maxInvocations have been reached -
      * core contracts shall still enforce a maxInvocation check during mint.
      */
     function syncProjectMaxInvocationsToCore(
-        uint256 _projectId,
-        address _coreContract
+        uint256 projectId,
+        address coreContract
     ) public {
         AuthLib.onlyArtist({
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: msg.sender
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: msg.sender
         });
 
-        uint256 maxInvocations = MaxInvocationsLib
-            .syncProjectMaxInvocationsToCore({
-                _projectId: _projectId,
-                _coreContract: _coreContract,
-                maxInvocationsProjectConfig: _maxInvocationsProjectConfigMapping[
-                    _coreContract
-                ][_projectId]
-            });
-        emit ProjectMaxInvocationsLimitUpdated(
-            _projectId,
-            _coreContract,
-            maxInvocations
-        );
+        MaxInvocationsLib.syncProjectMaxInvocationsToCore({
+            projectId: projectId,
+            coreContract: coreContract
+        });
     }
 
     /**
-     * @notice Purchases a token from project `_projectId` and sets
-     * the token's owner to `_to`.
+     * @notice Purchases a token from project `projectId` and sets
+     * the token's owner to `to`.
      * Note: Collectors should not send excessive value with their purchase
      * transaction, because the artist has the ability to change the auction
      * details at any time, including the price.
-     * @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.
-     * @param _ownedNFTAddress ERC-721 NFT holding the project token owned by
+     * @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.
+     * @param ownedNFTAddress ERC-721 NFT holding the project token owned by
      * msg.sender being used to claim right to purchase.
-     * @param _ownedNFTTokenId ERC-721 NFT token ID owned by msg.sender being used
+     * @param ownedNFTTokenId ERC-721 NFT token ID owned by msg.sender being used
      * to claim right to purchase.
      * @return tokenId Token ID of minted token
      */
     function purchaseTo(
-        address _to,
-        uint256 _projectId,
-        address _coreContract,
-        address _ownedNFTAddress,
-        uint256 _ownedNFTTokenId,
-        address _vault
+        address to,
+        uint256 projectId,
+        address coreContract,
+        address ownedNFTAddress,
+        uint256 ownedNFTTokenId,
+        address vault
     ) public payable nonReentrant returns (uint256 tokenId) {
         // CHECKS
-        MaxInvocationsLib.MaxInvocationsProjectConfig
-            storage _maxInvocationsProjectConfig = _maxInvocationsProjectConfigMapping[
-                _coreContract
-            ][_projectId];
-
-        DALinLib.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
+        });
 
         // getPriceLin reverts if auction is unconfigured or has not started
-        uint256 pricePerTokenInWei = DALinLib.getPriceLin(
-            _auctionProjectConfig
-        );
+        uint256 pricePerTokenInWei = DALinLib.getPriceLin({
+            projectId: projectId,
+            coreContract: coreContract
+        });
         require(msg.value >= pricePerTokenInWei, "Min value to mint req.");
 
         // require token used to claim to be in set of allowlisted NFTs
         require(
             TokenHolderLib.isAllowlistedNFT({
-                holderProjectConfig: _allowedProjectHoldersMapping[
-                    _coreContract
-                ][_projectId],
-                _ownedNFTAddress: _ownedNFTAddress,
-                _ownedNFTTokenId: _ownedNFTTokenId
+                projectId: projectId,
+                coreContract: coreContract,
+                ownedNFTAddress: ownedNFTAddress,
+                ownedNFTTokenId: ownedNFTTokenId
             }),
             "Only allowlisted NFTs"
         );
@@ -888,39 +798,39 @@ contract MinterDALinHolderV5 is
         // NOTE: delegate-vault handling **begins here**.
 
         // handle that the vault may be either the `msg.sender` in the case
-        // that there is not a true vault, or may be `_vault` if one is
+        // that there is not a true vault, or may be `vault` if one is
         // provided explicitly (and it is valid).
-        address vault = msg.sender;
-        if (_vault != address(0)) {
+        address vault_ = msg.sender;
+        if (vault != address(0)) {
             // If a vault is provided, it must be valid, otherwise throw rather
             // than optimistically-minting with original `msg.sender`.
             // Note, we do not check `checkDelegateForAll` or `checkDelegateForContract` as well,
             // as they are known to be implicitly checked by calling `checkDelegateForToken`.
-            bool isValidVault = delegationRegistryContract
+            bool isValidVault = _delegationRegistryContract
                 .checkDelegateForToken({
                     delegate: msg.sender,
-                    vault: _vault,
-                    contract_: _coreContract,
-                    tokenId: _ownedNFTTokenId
+                    vault: vault,
+                    contract_: coreContract,
+                    tokenId: ownedNFTTokenId
                 });
             require(isValidVault, "Invalid delegate-vault pairing");
-            vault = _vault;
+            vault_ = vault;
         }
 
         // EFFECTS
-        tokenId = minterFilter.mint_joo({
-            _to: _to,
-            _projectId: _projectId,
-            _coreContract: _coreContract,
-            _sender: vault
+        tokenId = _minterFilter.mint_joo({
+            to: to,
+            projectId: projectId,
+            coreContract: coreContract,
+            sender: vault_
         });
 
         // NOTE: delegate-vault handling **ends here**.
 
-        MaxInvocationsLib.validatePurchaseEffectsInvocations(
-            tokenId,
-            _maxInvocationsProjectConfig
-        );
+        MaxInvocationsLib.validateMintEffectsInvocations({
+            tokenId: tokenId,
+            coreContract: coreContract
+        });
 
         // INTERACTIONS
         // require vault to own NFT used to redeem
@@ -931,20 +841,15 @@ contract MinterDALinHolderV5 is
          * function is non-reentrant, so this is extra cautious.
          */
         TokenHolderLib.validateNFTOwnership({
-            _ownedNFTAddress: _ownedNFTAddress,
-            _ownedNFTTokenId: _ownedNFTTokenId,
-            _targetOwner: vault
+            ownedNFTAddress: ownedNFTAddress,
+            ownedNFTTokenId: ownedNFTTokenId,
+            targetOwner: vault_
         });
 
-        bool isEngine = SplitFundsLib.isEngine(
-            _coreContract,
-            _isEngineCaches[_coreContract]
-        );
-        SplitFundsLib.splitFundsETH({
-            _projectId: _projectId,
-            _pricePerTokenInWei: pricePerTokenInWei,
-            _coreContract: _coreContract,
-            _isEngine: isEngine
+        SplitFundsLib.splitFundsETHRefundSender({
+            projectId: projectId,
+            pricePerTokenInWei: pricePerTokenInWei,
+            coreContract: coreContract
         });
 
         return tokenId;