@artblocks/contracts 1.0.4 → 1.2.0

package/contracts/split/SplitAtomicV0.sol

@@ -0,0 +1,265 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+// @dev fixed to specific solidity version for clarity and for more clear
+// source code verification purposes.
+pragma solidity 0.8.22;
+
+import {ISplitAtomicV0, Split} from "../interfaces/v0.8.x/ISplitAtomicV0.sol";
+
+import {IERC20} from "@openzeppelin-5.0/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin-5.0/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/**
+ * @title SplitAtomicV0
+ * @author Art Blocks Inc.
+ * @notice This contract splits received funds according to the configured
+ * `splits`, which are immutably configured at initialization time.
+ * Each split is defined as a `recipient` address and a `basisPoints` value.
+ * The total of all `basisPoints` values must add up to 10_000 (100%), which
+ * is verified at initialization time. All splits must be non-zero.
+ *
+ * When the contract receives funds, it splits the funds according to the
+ * configured `splits`. The contract can also manually split any funds that
+ * were sent outside of the `receive` function via the `drainETH` function.
+ * Additionally, a `drainERC20` function is provided to split any ERC20 tokens
+ * that were sent to the contract.
+ *
+ * There may be a small amount of funds left behind when splitting funds, due
+ * to integer division rounding down. This is conservatively safe (will always
+ * run a split), but may leave a small amount of funds behind (e.g. a few wei).
+ * The small amount of funds left behind can always be drained later, but
+ * likely never worth the gas.
+ */
+contract SplitAtomicV0 is ISplitAtomicV0 {
+    // simplified, initializable reentrancy guard
+    uint256 private constant _NOT_ENTERED = 1;
+    uint256 private constant _ENTERED = 2;
+    uint256 private constant _NOT_INITIALIZED = 0;
+    uint256 private _status; // initial value: _NOT_INITIALIZED (0)
+
+    // public type
+    bytes32 public constant type_ = "SplitAtomicV0";
+
+    // private array of Splits
+    Split[] private _splits;
+
+    /**
+     * @dev Prevents contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and making it call a
+     * `private` function that does the actual work.
+     * @dev prefer to use modifier here due to wrapped function behavior
+     */
+    modifier nonReentrant() {
+        _nonReentrantBefore();
+        _;
+        _nonReentrantAfter();
+    }
+
+    /**
+     * @notice receive function splits received funds according to the
+     * configured `splits`.
+     * Reverts if contract is not yet initialized.
+     * Non-reentrant function.
+     * @dev This function automatically splits funds when the native token of a
+     * blockchain is sent to the contract. It is important to note that this
+     * function uses an unspecified amount of gas, and therefore sending funds
+     * to this contract via the deprecated `transfer` method is not supported.
+     * @dev This function relies on being non-reentrant for security.
+     */
+    receive() external payable nonReentrant {
+        // split received funds
+        // @dev reverts if not already initialized
+        _splitETH(msg.value);
+    }
+
+    /**
+     * @notice Initializes the contract with the provided `splits`.
+     * This function should be called atomically, immediately after deployment.
+     * Only callable once.
+     * @param splits Splits to configure the contract with. Must add up to
+     * 10_000 BPS.
+     */
+    function initialize(Split[] calldata splits) external {
+        // initialize reentrancy guard
+        // @dev this reverts if already initialized, preventing this function
+        // from ever being called more than once
+        _reentrancyGuardInit();
+        // validate splits
+        uint256 totalBasisPoints = 0;
+        uint256 splitsLength = splits.length;
+        // @dev splits length implicitly checked to be > 0 via totalBasisPoints
+        // check after loop
+        for (uint256 i; i < splitsLength; ) {
+            Split memory split = splits[i];
+            uint256 bps = split.basisPoints;
+            require(bps > 0 && bps <= 10_000, "Invalid basis points");
+            // push the splits to the storage array
+            _splits.push(split);
+            // track total basis points for totals validation after loop
+            // @dev overflow checked automatically in solidity 0.8
+            totalBasisPoints += bps;
+            // @dev efficient unchecked increment
+            unchecked {
+                ++i;
+            }
+        }
+        require(totalBasisPoints == 10_000, "Invalid total basis points");
+        // emit initialized event
+        emit Initialized(type_);
+    }
+
+    /**
+     * @notice Drains the contract's balance to the configured `splits`.
+     * Reverts if not initialized.
+     * @dev This function is useful for draining the contract's balance to the
+     * configured `splits` in the event that the contract receives funds via
+     * a force-send (e.g. `SELFDESTRUCT` or `SENDALL`) operation.
+     * @dev This function relies on being non-reentrant for security.
+     */
+    function drainETH() external nonReentrant {
+        // split contract balance
+        uint256 balance = address(this).balance;
+        if (balance > 0) {
+            // @dev reverts if not initialized
+            _splitETH(balance);
+        }
+        emit DrainedETH();
+    }
+
+    /**
+     * @notice Drains the contract's balance of an input ERC20 token to the
+     * configured `splits`.
+     * Reverts if not initialized
+     * @dev This function is useful for draining the contract's balance of an
+     * ERC20 token to the configured `splits`. ERC20 tokens are not split upon
+     * receiving (due to transfers not always calling a receive hook),
+     * therefore this function provides critical functionality for this
+     * contract.
+     * @dev This function relies on being non-reentrant for security.
+     * @param ERC20TokenAddress The address of the ERC20 token to split.
+     */
+    function drainERC20(address ERC20TokenAddress) external nonReentrant {
+        // split contract balance of ERC20 token
+        uint256 balance = IERC20(ERC20TokenAddress).balanceOf(address(this));
+        if (balance > 0) {
+            // @dev reverts if not initialized
+            _splitERC20({ERC20TokenAddress: ERC20TokenAddress, value: balance});
+        }
+        emit DrainedERC20(ERC20TokenAddress);
+    }
+
+    /**
+     * @notice Returns the configured `splits`.
+     * @return Split[] memory The configured `splits`.
+     */
+    function getSplits() external view returns (Split[] memory) {
+        return _splits;
+    }
+
+    /**
+     * @notice Splits the input `valueInWei` of ETH to the configured `splits`.
+     * Reverts if any transfers fail. Reverts if called outside of a
+     * non-reentrant function. Reverts if not initialized.
+     * @param valueInWei The amount of ETH to split.
+     */
+    function _splitETH(uint256 valueInWei) internal {
+        // require only called in the context of a non-reentrant function
+        // @dev this provides fault-tolerant behavior for reentrancy guards
+        // @dev this also implicitly verifies contract is initialized
+        // @dev no cover on next line else banch due to fault-tolerant check
+        require(_status == _ENTERED, "only in non-reentrant function");
+        // split funds
+        uint256 splitsLength = _splits.length;
+        for (uint256 i; i < splitsLength; ) {
+            Split memory split = _splits[i];
+            // @dev overflow checked automatically in solidity 0.8
+            // @dev integer division rounds down, which is conservatively safe
+            // when splitting funds. Will not run out of funds, but may leave a
+            // small amount behind (e.g. a few wei). Can always be drained
+            // later, but likely never worth the gas.
+            uint256 splitValue = (valueInWei * split.basisPoints) / 10_000;
+            // send funds
+            (bool success, ) = split.recipient.call{value: splitValue}("");
+            require(success, "Payment failed");
+            // @dev efficient unchecked increment
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /**
+     * @notice Splits the input `value` of ERC20 token at `ERC20TokenAddress`
+     * to the configured `splits`.
+     * Reverts if any transfers fail. Reverts if called outside of a
+     * non-reentrant function. Reverts if not initialized.
+     * @param ERC20TokenAddress The address of the ERC20 token to split.
+     * @param value The amount of the ERC20 token to split.
+     */
+    function _splitERC20(address ERC20TokenAddress, uint256 value) internal {
+        // require only called in the context of a non-reentrant function
+        // @dev this provides fault-tolerant behavior for reentrancy guards
+        // @dev this also implicitly verifies contract is initialized
+        // @dev no cover on next line else banch due to fault-tolerant check
+        require(_status == _ENTERED, "only in non-reentrant function");
+        // split funds
+        uint256 splitsLength = _splits.length;
+        IERC20 token = IERC20(ERC20TokenAddress);
+        for (uint256 i; i < splitsLength; ) {
+            Split memory split = _splits[i];
+            // @dev overflow checked automatically in solidity 0.8
+            // @dev integer division rounds down, which is conservatively safe
+            // when splitting funds. Will not run out of funds, but may leave a
+            // small amount behind (e.g. a few wei). Can always be drained
+            // later, but likely never worth the gas.
+            uint256 splitValue = (value * split.basisPoints) / 10_000;
+            // transfer ERC20 tokens
+            // @dev use SafeERC20 to only revert if ERC20 transfer returns
+            // false, not if it returns nothing (which is the behavior of some
+            // ERC20 tokens, and we don't want to forever lock those tokens)
+            SafeERC20.safeTransfer({
+                token: token,
+                to: split.recipient,
+                value: splitValue
+            });
+            // @dev efficient unchecked increment
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /**
+     * @notice Initializes the reentrancy guard. This function will revert if
+     * the contract is already initialized.
+     */
+    function _reentrancyGuardInit() private {
+        // require not already initialized
+        require(_status == _NOT_INITIALIZED, "Already initialized");
+        // set status to not entered
+        _status = _NOT_ENTERED;
+    }
+
+    /**
+     * @notice Sets the reentrancy guard status to `_ENTERED`.
+     * Reverts if the guard is already entered.
+     */
+    function _nonReentrantBefore() private {
+        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
+        // Any calls to nonReentrant after this point will fail
+        _status = _ENTERED;
+    }
+
+    /**
+     * @notice Sets the reentrancy guard status to `_NOT_ENTERED`, allowing
+     * calls to `nonReentrant` functions again.
+     */
+    function _nonReentrantAfter() private {
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        _status = _NOT_ENTERED;
+    }
+}

package/contracts/split/split-provider/SplitProviderV0.sol

@@ -0,0 +1,201 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity 0.8.22;
+
+import {ISplitProviderV0} from "../../interfaces/v0.8.x/ISplitProviderV0.sol";
+import {ISplitFactoryV2} from "../../interfaces/v0.8.x/integration-refs/splits-0x-v2/ISplitFactoryV2.sol";
+
+import {ERC165} from "@openzeppelin-5.0/contracts/utils/introspection/ERC165.sol";
+
+/**
+ * @title SplitProviderV0
+ * @author Art Blocks Inc.
+ * @notice Split Provider to get or create immutable split contracts.
+ * This version of SplitProvider integrates with 0xSplits v2 to provide
+ * immutable split contracts.
+ * This contract is permissionless and does not have an owner. It is intended
+ * to be used by other contracts to create immutable split contracts, while
+ * adding a layer of abstraction to reduce the complexity of interacting with
+ * 0xSplits v2 directly, as well as to enable future migration paths to new
+ * upgrades.
+ * ----------------------------------------------------------------------------
+ * All split contracts will be created with the following properties:
+ * - The split contract will be immutable.
+ * - The split contract will be created with the provided split parameters.
+ * - The split contract includes zero distribution incentive.
+ * - The split contract will be created at a deterministic address, given the
+ *   input split parameters and contract calling this contract (as well as the
+ *   third party 0xSplits SplitFactoryV2 address).
+ */
+contract SplitProviderV0 is ISplitProviderV0, ERC165 {
+    bytes32 private constant _TYPE = "SplitProviderV0";
+
+    // 0xSplits SplitFactoryV2 address immutably configured on this contract
+    ISplitFactoryV2 private immutable _splitFactoryV2;
+
+    /**
+     * @notice Construct a new SplitProviderV0 contract.
+     * @param splitFactoryV2Address The immutable 0xSplits SplitFactoryV2 address.
+     */
+    constructor(ISplitFactoryV2 splitFactoryV2Address) {
+        _splitFactoryV2 = ISplitFactoryV2(splitFactoryV2Address);
+    }
+
+    /**
+     * @notice Gets or creates an immutable splitter contract at a deterministic address.
+     * Splits in the splitter contract are determined by the input split parameters,
+     * so we can safely create the splitter contract at a deterministic address (or use
+     * the existing splitter contract if it already exists at that address).
+     * Returns null address if no royalties are due.
+     * @dev Uses the 0xSplits v2 implementation to create a splitter contract
+     * @dev Intentionally unpermissioned; no owner required; all created splits
+     * are immutable and deterministic
+     * @param splitInputs The split input parameters.
+     * @return splitter The newly created splitter contract address.
+     */
+    function getOrCreateSplitter(
+        SplitInputs calldata splitInputs
+    ) external override returns (address) {
+        // edge case: no royalties due; return zero address
+        if (
+            splitInputs.artistTotalRoyaltyPercentage +
+                splitInputs.renderProviderSecondarySalesBPS +
+                splitInputs.platformProviderSecondarySalesBPS ==
+            0
+        ) {
+            return address(0);
+        }
+        // create Split struct from SplitInputs
+        ISplitFactoryV2.Split memory splitParams = _getSplitParams({
+            splitInputs: splitInputs
+        });
+        // use sender as salt to ensure unique splitters across contracts/partners for accounting
+        bytes32 salt = bytes32(bytes20(msg.sender));
+        // determine if splitter already exists
+        (address splitter, bool exists) = _splitFactoryV2.isDeployed({
+            _splitParams: splitParams,
+            _owner: address(0), // no owner, immutable,
+            _salt: salt
+        });
+        if (!exists) {
+            // create new splitter contract
+            // @dev no need to re-assign returned address; isDeployed already populated it
+            _splitFactoryV2.createSplitDeterministic({
+                _splitParams: splitParams,
+                _owner: address(0), // no owner, immutable
+                _creator: address(this),
+                _salt: salt
+            });
+
+            // emit event for new splitter creation
+            emit SplitterCreated({splitter: splitter});
+        }
+
+        return splitter;
+    }
+
+    /**
+     * @notice Get the immutable 0xSplits SplitFactoryV2 address used by this SplitProviderV0.
+     * @return splitFactoryV2 The 0xSplits SplitFactoryV2 address.
+     */
+    function getSplitFactoryV2() external view returns (ISplitFactoryV2) {
+        return _splitFactoryV2;
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override returns (bool) {
+        // broadcast support of the getOrCreateSplitter function
+        // @dev intentionally only including getOrCreateSplitter, as that is the only function
+        // that is intended to be used for on-chain integration (type_ is for indexing and introspection only)
+        return
+            interfaceId == this.getOrCreateSplitter.selector ||
+            super.supportsInterface(interfaceId);
+    }
+
+    /**
+     * @notice Indicates the type of the contract, e.g. `SplitProviderV0`.
+     * @return type_ The type of the contract.
+     */
+    function type_() external pure returns (bytes32) {
+        return _TYPE;
+    }
+
+    /**
+     * Converts the split inputs to the split parameters used by 0xSplits V2.
+     * This function assumes there is at least one party with a non-zero allocation,
+     * and should not be called if there are no royalties due.
+     * @param splitInputs The split input parameters.
+     * @return splitParams The split parameters in the form used by 0xSplits V2.
+     */
+    function _getSplitParams(
+        SplitInputs calldata splitInputs
+    ) private pure returns (ISplitFactoryV2.Split memory splitParams) {
+        // define allocations in BPS to avoid any rounding errors
+        uint256 artistAndAdditionalRoyaltyPercentage = splitInputs
+            .artistTotalRoyaltyPercentage;
+        uint256 artistAndAdditionalRoyaltyBPS = 100 *
+            artistAndAdditionalRoyaltyPercentage;
+        // load render provider royalty BPS
+        uint256 renderProviderRoyaltyBPS = splitInputs
+            .renderProviderSecondarySalesBPS;
+        // load platform provider royalty BPS
+        uint256 platformProviderRoyaltyBPS = splitInputs
+            .platformProviderSecondarySalesBPS;
+
+        bool artistNonZero = artistAndAdditionalRoyaltyPercentage > 0 &&
+            splitInputs.additionalPayeePercentage < 100;
+        bool additionalPayeeNonZero = artistAndAdditionalRoyaltyPercentage >
+            0 &&
+            splitInputs.additionalPayeePercentage > 0;
+        bool renderNonZero = renderProviderRoyaltyBPS > 0;
+        bool platformNonZero = platformProviderRoyaltyBPS > 0;
+
+        // allocate memory for splitParams arrays
+        uint256 partyLength = (artistNonZero ? 1 : 0) +
+            (additionalPayeeNonZero ? 1 : 0) +
+            (renderNonZero ? 1 : 0) +
+            (platformNonZero ? 1 : 0);
+        splitParams.recipients = new address[](partyLength);
+        splitParams.allocations = new uint256[](partyLength);
+        splitParams.totalAllocation =
+            artistAndAdditionalRoyaltyBPS +
+            renderProviderRoyaltyBPS +
+            platformProviderRoyaltyBPS;
+
+        // populate each party's split
+        uint256 currentIndex = 0;
+        if (artistNonZero) {
+            splitParams.recipients[currentIndex] = splitInputs.artist;
+            // @dev percent * 100 converts to BPS
+            splitParams.allocations[currentIndex++] =
+                artistAndAdditionalRoyaltyPercentage *
+                (100 - splitInputs.additionalPayeePercentage);
+        }
+        if (additionalPayeeNonZero) {
+            splitParams.recipients[currentIndex] = splitInputs.additionalPayee;
+            // @dev percent * 100 converts to BPS
+            splitParams.allocations[currentIndex++] =
+                artistAndAdditionalRoyaltyPercentage *
+                splitInputs.additionalPayeePercentage;
+        }
+        if (renderNonZero) {
+            splitParams.recipients[currentIndex] = splitInputs
+                .renderProviderSecondarySalesAddress;
+            splitParams.allocations[currentIndex++] = renderProviderRoyaltyBPS;
+        }
+        if (platformNonZero) {
+            splitParams.recipients[currentIndex] = splitInputs
+                .platformProviderSecondarySalesAddress;
+            splitParams.allocations[
+                currentIndex // no need to increment, last element
+            ] = platformProviderRoyaltyBPS;
+        }
+
+        // @dev leave distribution incentive as zero on all splits
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artblocks/contracts",
-  "version": "1.0.4",
+  "version": "1.2.0",
   "description": "Smart contracts used by Art Blocks",
   "files": [
     "/contracts/**/*.sol",
@@ -20,91 +20,125 @@
     "lint": "prettier --check 'contracts/**/*.sol' && prettier --check 'scripts/**/*.ts' && prettier --check 'test/**/*.ts' && npx eslint 'test/**/*.ts'",
     "remix": "remixd -s ./ --remix-ide https://remix.ethereum.org",
     "codegen": "yarn --cwd=\"../..\" codegen:project contracts",
-    "deploy:dev:v3-engine": "yarn codegen && yarn require-low-gas goerli && NODE_ENV=dev yarn hardhat run --network goerli scripts/engine/V3/generic-engine-deployer.ts",
-    "deploy:dev-arbitrum:v3-engine": "yarn codegen && yarn require-low-gas arbitrum-goerli && NODE_ENV=arbitrum-dev yarn hardhat run --network arbitrum-goerli scripts/engine/V3/generic-engine-deployer.ts",
-    "deploy:staging-arbitrum:v3-engine": "yarn codegen && yarn require-low-gas arbitrum-goerli && NODE_ENV=arbitrum-staging yarn hardhat run --network arbitrum-goerli scripts/engine/V3/generic-engine-deployer.ts",
-    "deploy:arbitrum:v3-engine": "yarn codegen && yarn require-low-gas arbitrum && NODE_ENV=arbitrum yarn hardhat run --network arbitrum scripts/engine/V3/generic-engine-deployer.ts",
-    "deploy:staging:v3-engine": "yarn codegen && yarn require-low-gas goerli && NODE_ENV=staging yarn hardhat run --network goerli scripts/engine/V3/generic-engine-deployer.ts",
-    "deploy:mainnet:v3-engine": "yarn codegen && yarn require-low-gas mainnet && NODE_ENV=mainnet yarn hardhat run --network mainnet scripts/engine/V3/generic-engine-deployer.ts",
-    "deploy:goerli:minter": "yarn require-low-gas goerli && yarn hardhat run --network goerli scripts/minter-deployments/V3/generic-minter-deployer-v3core.ts",
-    "deploy:mainnet:minter": "yarn require-low-gas mainnet && yarn hardhat run --network mainnet scripts/minter-deployments/V3/generic-minter-deployer-v3core.ts",
+    "get-init-code": "yarn hardhat run --network sepolia scripts/get-init-code.ts",
+    "verify": "yarn hardhat run scripts/verify.ts --network",
+    "deploy:v3-engine:dev": "yarn codegen && yarn require-low-gas sepolia && NODE_ENV=dev yarn hardhat run --network sepolia scripts/engine/V3/batch-create-engine-contracts.ts",
+    "deploy:v3-engine:dev-arbitrum": "yarn codegen && yarn require-low-gas arbitrum-sepolia && NODE_ENV=arbitrum-dev yarn hardhat run --network arbitrum-sepolia scripts/engine/V3/batch-create-engine-contracts.ts",
+    "deploy:v3-engine:staging-arbitrum": "yarn codegen && yarn require-low-gas arbitrum-sepolia && NODE_ENV=arbitrum-staging yarn hardhat run --network arbitrum-sepolia scripts/engine/V3/batch-create-engine-contracts.ts",
+    "deploy:v3-engine:arbitrum": "yarn codegen && yarn require-low-gas arbitrum && NODE_ENV=arbitrum yarn hardhat run --network arbitrum scripts/engine/V3/batch-create-engine-contracts.ts",
+    "deploy:v3-engine:base": "yarn codegen && yarn require-low-gas base && NODE_ENV=base yarn hardhat run --network base scripts/engine/V3/batch-create-engine-contracts.ts",
+    "deploy:v3-engine:staging": "yarn codegen && yarn require-low-gas sepolia && NODE_ENV=staging yarn hardhat run --network sepolia scripts/engine/V3/batch-create-engine-contracts.ts",
+    "deploy:v3-engine:mainnet": "yarn codegen && yarn require-low-gas mainnet && NODE_ENV=mainnet yarn hardhat run --network mainnet scripts/engine/V3/batch-create-engine-contracts.ts",
+    "post-deploy:v3-engine:dev": "yarn codegen && yarn require-low-gas sepolia && NODE_ENV=dev yarn hardhat run --network sepolia scripts/engine/V3/post-batch-create-engine-contracts.ts",
+    "post-deploy:v3-engine:dev-arbitrum": "yarn codegen && yarn require-low-gas arbitrum-sepolia && NODE_ENV=arbitrum-dev yarn hardhat run --network arbitrum-sepolia scripts/engine/V3/post-batch-create-engine-contracts.ts",
+    "post-deploy:v3-engine:staging-arbitrum": "yarn codegen && yarn require-low-gas arbitrum-sepolia && NODE_ENV=arbitrum-staging yarn hardhat run --network arbitrum-sepolia scripts/engine/V3/post-batch-create-engine-contracts.ts",
+    "post-deploy:v3-engine:arbitrum": "yarn codegen && yarn require-low-gas arbitrum && NODE_ENV=arbitrum yarn hardhat run --network arbitrum scripts/engine/V3/post-batch-create-engine-contracts.ts",
+    "post-deploy:v3-engine:base": "yarn codegen && yarn require-low-gas base && NODE_ENV=base yarn hardhat run --network base scripts/engine/V3/post-batch-create-engine-contracts.ts",
+    "post-deploy:v3-engine:staging": "yarn codegen && yarn require-low-gas sepolia && NODE_ENV=staging yarn hardhat run --network sepolia scripts/engine/V3/post-batch-create-engine-contracts.ts",
+    "post-deploy:v3-engine:mainnet": "yarn codegen && yarn require-low-gas mainnet && NODE_ENV=mainnet yarn hardhat run --network mainnet scripts/engine/V3/post-batch-create-engine-contracts.ts",
     "deploy:shared-randomizer:goerli": "yarn require-low-gas goerli && yarn hardhat run --network goerli scripts/randomizer-deployments/shared-randomizer-deployer.ts",
+    "deploy:shared-randomizer:dev-sepolia": "yarn require-low-gas sepolia && NODE_ENV=dev yarn hardhat run --network sepolia scripts/randomizer-deployments/shared-randomizer-deployer.ts",
     "deploy:shared-randomizer:mainnet": "yarn require-low-gas mainnet && yarn hardhat run --network mainnet scripts/randomizer-deployments/shared-randomizer-deployer.ts",
     "deploy:shared-randomizer:arbitrum-goerli": "yarn require-low-gas arbitrum-goerli && yarn hardhat run --network arbitrum-goerli scripts/randomizer-deployments/shared-randomizer-deployer.ts",
     "deploy:shared-randomizer:arbitrum": "yarn require-low-gas arbitrum && yarn hardhat run --network arbitrum scripts/randomizer-deployments/shared-randomizer-deployer.ts",
+    "deploy:shared-randomizer:base": "yarn require-low-gas base && yarn hardhat run --network base scripts/randomizer-deployments/shared-randomizer-deployer.ts",
     "deploy:shared-minter-filter:goerli": "yarn require-low-gas goerli && yarn hardhat run --network goerli scripts/minter-filter-deployments/shared-minter-filter-deployer.ts",
+    "deploy:shared-minter-filter:dev-sepolia": "yarn require-low-gas sepolia && NODE_ENV=dev yarn hardhat run --network sepolia scripts/minter-filter-deployments/shared-minter-filter-deployer.ts",
     "deploy:shared-minter-filter:mainnet": "yarn require-low-gas mainnet && yarn hardhat run --network mainnet scripts/minter-filter-deployments/shared-minter-filter-deployer.ts",
     "deploy:shared-minter-filter:arbitrum-goerli": "yarn require-low-gas arbitrum-goerli && yarn hardhat run --network arbitrum-goerli scripts/minter-filter-deployments/shared-minter-filter-deployer.ts",
     "deploy:shared-minter-filter:arbitrum": "yarn require-low-gas arbitrum && yarn hardhat run --network arbitrum scripts/minter-filter-deployments/shared-minter-filter-deployer.ts",
-    "deploy:shared-shared-minters:goerli": "yarn require-low-gas goerli && yarn hardhat run --network goerli scripts/minter-deployments/shared-minters-deployer.ts",
-    "deploy:shared-shared-minters:mainnet": "yarn require-low-gas mainnet && yarn hardhat run --network mainnet scripts/minter-deployments/shared-minters-deployer.ts",
-    "deploy:shared-shared-minters:arbitrum-goerli": "yarn require-low-gas arbitrum-goerli && yarn hardhat run --network arbitrum-goerli scripts/minter-deployments/shared-minters-deployer.ts",
-    "deploy:shared-shared-minters:arbitrum": "yarn require-low-gas arbitrum && yarn hardhat run --network arbitrum scripts/minter-deployments/shared-minters-deployer.ts",
+    "deploy:shared-minter-filter:base": "yarn require-low-gas base && yarn hardhat run --network base scripts/minter-filter-deployments/shared-minter-filter-deployer.ts",
+    "deploy:shared-minters:goerli": "yarn require-low-gas goerli && yarn hardhat run --network goerli scripts/minter-deployments/shared-minters-deployer.ts",
+    "deploy:shared-minters:sepolia": "yarn require-low-gas sepolia && yarn hardhat run --network sepolia scripts/minter-deployments/shared-minters-deployer.ts",
+    "deploy:shared-minters:mainnet": "yarn require-low-gas mainnet && yarn hardhat run --network mainnet scripts/minter-deployments/shared-minters-deployer.ts",
+    "deploy:shared-minters:arbitrum-goerli": "yarn require-low-gas arbitrum-goerli && yarn hardhat run --network arbitrum-goerli scripts/minter-deployments/shared-minters-deployer.ts",
+    "deploy:shared-minters:arbitrum": "yarn require-low-gas arbitrum && yarn hardhat run --network arbitrum scripts/minter-deployments/shared-minters-deployer.ts",
+    "deploy:shared-minters:base": "yarn require-low-gas base && yarn hardhat run --network base scripts/minter-deployments/shared-minters-deployer.ts",
+    "deploy:splits-factory:dev": "yarn require-low-gas sepolia && NODE_ENV=dev yarn hardhat run --network sepolia scripts/splits/splits-factory-deployer.ts",
+    "deploy:splits-factory:staging": "yarn require-low-gas sepolia && NODE_ENV=staging yarn hardhat run --network sepolia scripts/splits/splits-factory-deployer.ts",
+    "deploy:splits-factory:mainnet": "yarn require-low-gas mainnet && NODE_ENV=mainnet yarn hardhat run --network mainnet scripts/splits/splits-factory-deployer.ts",
+    "deploy:core-registry:dev-sepolia": "yarn require-low-gas sepolia && NODE_ENV=dev yarn hardhat run --network sepolia scripts/core-registry-deployments/core-registry-deployer.ts",
+    "dependency-registry:upload-script:mainnet": "NODE_ENV=mainnet yarn hardhat run --network mainnet ./scripts/propose-add-dependency-script-transactions.ts",
     "require-low-gas": "yarn hardhat run scripts/require-low-gas.ts --network",
-    "pre-commit": "yarn lint"
+    "pre-commit": "yarn lint",
+    "deploy:deprecated:mainnet:v3-engine-shared": "yarn codegen && yarn require-low-gas mainnet && NODE_ENV=mainnet yarn hardhat run --network mainnet scripts/engine/V3/generic-engine-shared-suite-deployer.ts",
+    "deploy:deprecated:dev:v3-engine": "yarn codegen && yarn require-low-gas goerli && NODE_ENV=dev yarn hardhat run --network goerli scripts/engine/V3/deprecated/generic-engine-deployer.ts",
+    "deploy:deprecated:staging:v3-engine": "yarn codegen && yarn require-low-gas goerli && NODE_ENV=staging yarn hardhat run --network goerli scripts/engine/V3/deprecated/generic-engine-deployer.ts",
+    "deploy:deprecated:dev-arbitrum:v3-engine": "yarn codegen && yarn require-low-gas arbitrum-goerli && NODE_ENV=arbitrum-dev yarn hardhat run --network arbitrum-goerli scripts/engine/V3/deprecated/generic-engine-deployer.ts",
+    "deploy:deprecated:staging-arbitrum:v3-engine": "yarn codegen && yarn require-low-gas arbitrum-goerli && NODE_ENV=arbitrum-staging yarn hardhat run --network arbitrum-goerli scripts/engine/V3/deprecated/generic-engine-deployer.ts",
+    "deploy:deprecated:arbitrum:v3-engine": "yarn codegen && yarn require-low-gas arbitrum && NODE_ENV=arbitrum yarn hardhat run --network arbitrum scripts/engine/V3/deprecated/generic-engine-deployer.ts",
+    "deploy:deprecated:mainnet:v3-engine": "yarn codegen && yarn require-low-gas mainnet && NODE_ENV=mainnet yarn hardhat run --network mainnet scripts/engine/V3/deprecated/generic-engine-deployer.ts",
+    "deploy:deprecated:goerli:non-shared-minter": "yarn require-low-gas goerli && yarn hardhat run --network goerli scripts/minter-deployments/V3/generic-minter-deployer-v3core.ts",
+    "deploy:deprecated:mainnet:non-shared-minter": "yarn require-low-gas mainnet && yarn hardhat run --network mainnet scripts/minter-deployments/V3/generic-minter-deployer-v3core.ts"
   },
   "devDependencies": {
-    "@aws-sdk/client-s3": "^3.398.0",
-    "@aws-sdk/credential-providers": "^3.398.0",
-    "@defi-wonderland/smock": "^2.3.5",
+    "@aws-sdk/client-s3": "^3.554.0",
+    "@aws-sdk/credential-providers": "^3.554.0",
+    "@defi-wonderland/smock": "^2.4.0",
     "@gnosis.pm/safe-contracts": "^1.3.0",
     "@gnosis.pm/safe-core-sdk": "^2.1.0",
     "@gnosis.pm/safe-core-sdk-types": "^1.7.0",
     "@gnosis.pm/safe-ethers-lib": "1.1.0",
     "@gnosis.pm/safe-service-client": "^1.4.0",
-    "@nomicfoundation/hardhat-network-helpers": "^1.0.8",
+    "@nomicfoundation/hardhat-chai-matchers": "^1.0.0",
+    "@nomicfoundation/hardhat-ledger": "^1.0.2",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.10",
     "@nomiclabs/hardhat-ethers": "^2.2.1",
-    "@nomiclabs/hardhat-etherscan": "^3.1.4",
     "@nomiclabs/hardhat-solhint": "^3.0.0",
     "@nomiclabs/hardhat-truffle5": "^2.0.7",
     "@nomiclabs/hardhat-waffle": "^2.0.3",
     "@nomiclabs/hardhat-web3": "^2.0.0",
     "@openzeppelin/hardhat-upgrades": "^1.28.0",
     "@openzeppelin/test-helpers": "^0.5.16",
-    "@remix-project/remixd": "^0.6.17",
-    "@typechain/ethers-v5": "^11.1.1",
-    "@types/jest": "^29.5.4",
-    "@types/mocha": "^10.0.1",
-    "@types/prompt": "^1.1.5",
-    "@typescript-eslint/eslint-plugin": "^6.4.1",
-    "@typescript-eslint/parser": "^6.4.1",
-    "aws-sdk-client-mock": "^3.0.0",
-    "chai": "^4.3.7",
+    "@safe-global/api-kit": "^1.3.1",
+    "@safe-global/protocol-kit": "1.3.0",
+    "@safe-global/safe-core-sdk-types": "2.3.0",
+    "@remix-project/remixd": "^0.6.30",
+    "@typechain/ethers-v5": "^11.1.2",
+    "@types/jest": "^29.5.12",
+    "@types/mocha": "^10.0.6",
+    "@types/prompt": "^1.1.8",
+    "@typescript-eslint/eslint-plugin": "^7.6.0",
+    "@typescript-eslint/parser": "^7.6.0",
+    "aws-sdk-client-mock": "^3.0.1",
+    "chai": "^4.3.10",
     "coveralls": "^3.1.1",
-    "dotenv": "^16.3.1",
-    "eslint": "^8.46.0",
+    "dotenv": "^16.4.5",
+    "eslint": "^8.56.0",
     "eslint-config-custom": "*",
-    "eslint-plugin-mocha": "^10.1.0",
-    "eslint-plugin-prettier": "^5.0.0",
-    "ethereum-waffle": "^4.0.10",
+    "eslint-plugin-mocha": "^10.4.2",
     "ethers": "^5.7.2",
-    "hardhat": "^2.17.1",
+    "hardhat": "^2.22.2",
     "hardhat-contract-sizer": "^2.10.0",
     "hardhat-docgen": "^1.3.0",
-    "hardhat-gas-reporter": "^1.0.9",
-    "husky": "^8.0.3",
+    "hardhat-gas-reporter": "^2.1.1",
+    "husky": "^9.0.11",
     "istanbul-combine": "^0.3.0",
     "keccak256": "^1.0.6",
-    "merkletreejs": "^0.3.9",
-    "prettier": "^3.0.2",
-    "prettier-plugin-solidity": "^1.1.1",
+    "merkletreejs": "^0.3.11",
+    "prettier": "^3.2.5",
+    "prettier-plugin-solidity": "^1.3.1",
     "prompt": "^1.3.0",
     "prompt-sync": "^4.2.0",
-    "solidity-coverage": "^0.8.4",
+    "readline-sync": "^1.4.10",
+    "solidity-coverage": "^0.8.12",
     "ts-node": "^9.1.1",
     "tsconfig": "*",
-    "typechain": "^8.3.1",
-    "typescript": "^5.2.2"
+    "typechain": "^8.3.2",
+    "typescript": "^5.4.5"
   },
   "author": "Art Blocks, Inc",
   "license": "LGPL-3.0-only",
   "dependencies": {
+    "@nomicfoundation/hardhat-verify": "^2.0.5",
     "@openzeppelin-0.5/contracts": "npm:@openzeppelin/contracts@2.5.1",
     "@openzeppelin-4.5/contracts": "npm:@openzeppelin/contracts@4.5.0",
     "@openzeppelin-4.7/contracts": "npm:@openzeppelin/contracts@4.7.1",
     "@openzeppelin-4.8/contracts-upgradeable": "npm:@openzeppelin/contracts-upgradeable@4.8.0",
-    "@urql/exchange-retry": "^1.2.0",
-    "graphql": "^16.8.0",
-    "urql": "^4.0.5"
+    "@openzeppelin-5.0/contracts": "npm:@openzeppelin/contracts@5.0.1",
+    "@urql/exchange-retry": "^1.2.1",
+    "graphql": "^16.8.1",
+    "solady": "^0.0.181",
+    "urql": "^4.0.7"
   }
 }