@artblocks/contracts 1.2.0 → 1.3.0

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

@@ -4,8 +4,9 @@
 pragma solidity ^0.8.0;
 
 import {IGenArt721CoreContractV3_Engine_Flex} from "../../interfaces/v0.8.x/IGenArt721CoreContractV3_Engine_Flex.sol";
+import {IBytecodeStorageReader_Base} from "../../interfaces/v0.8.x/IBytecodeStorageReader_Base.sol";
 
-import {BytecodeStorageWriter, BytecodeStorageReader} from "./BytecodeStorageV2.sol";
+import {BytecodeStorageWriter} from "./BytecodeStorageV2.sol";
 
 /**
  * @title Art Blocks V3 Engine Flex - External Helper Library
@@ -261,6 +262,8 @@ library V3FlexLib {
      * @notice Updates external asset dependency for project `_projectId` at
      * index `_index`, with data at BytecodeStorage-compatible address
      * `_assetAddress`.
+     * @dev This function may point to any BytecodeStorageReader-compatible
+     * on-chain asset, including a web3call contract.
      * @param _projectId Project to be updated.
      * @param _index Asset index.
      * @param _assetAddress Address of the on-chain asset.
@@ -446,6 +449,8 @@ library V3FlexLib {
      * @notice Adds an on-chain external asset dependency for project
      * `_projectId`, with data at BytecodeStorage-compatible address
      * `_assetAddress`.
+     * @dev This function may point to any BytecodeStorageReader-compatible
+     * on-chain asset, including a web3call contract.
      * @param _projectId Project to be updated.
      * @param _assetAddress  Address of the BytecodeStorageReader-compatible on-chain asset.
      */
@@ -499,13 +504,20 @@ library V3FlexLib {
 
     /**
      * @notice Returns external asset dependency for project `_projectId` at index `_index`.
-     * If the dependencyType is ONCHAIN, the `data` field will contain the extrated bytecode data and `cid`
+     * If the dependencyType is ONCHAIN, the `data` field will contain the read BytecodeStorage data and `cid`
      * will be an empty string. Conversly, for any other dependencyType, the `data` field will be an empty string
      * and the `bytecodeAddress` will point to the zero address.
+     * @dev If an ONCHAIN dependency is a web3call, the `data` field will be returned per the BytecodeStorageReader
+     * contract's active spec, which at the time of this writing is the special string "#web3call_contract#".
+     * @param _projectId Project to get external asset dependency for.
+     * @param _index Index of the external asset dependency.
+     * @param _bytecodeStorageReaderContract The bytecode storage reader contract to use for reading on-chain
+     * dependencies; only used if the dependency is of type ONCHAIN.
      */
     function projectExternalAssetDependencyByIndex(
         uint256 _projectId,
-        uint256 _index
+        uint256 _index,
+        IBytecodeStorageReader_Base _bytecodeStorageReaderContract
     )
         external
         view
@@ -533,7 +545,7 @@ library V3FlexLib {
                         IGenArt721CoreContractV3_Engine_Flex
                             .ExternalAssetDependencyType
                             .ONCHAIN)
-                        ? BytecodeStorageReader.readFromBytecode(
+                        ? _bytecodeStorageReaderContract.readFromBytecode(
                             _bytecodeAddress
                         )
                         : ""

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

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Art Blocks Min Price Library
+ * @notice This library is designed for the Art Blocks platform. It includes
+ * events to assist with minters that implement a minimum mint fee.
+ * @author Art Blocks Inc.
+ */
+
+library MinPriceLib {
+    /**
+     * @notice Min mint fee, in wei, was updated to be the
+     * provided value.
+     * @param minMintFee Min mint fee, in wei
+     */
+    event MinMintFeeUpdated(uint256 minMintFee);
+
+    // position of MinPrice Lib storage, using a diamond storage pattern
+    // for this library
+    bytes32 constant MIN_PRICE_LIB_STORAGE_POSITION =
+        keccak256("minpricelib.storage");
+
+    // Diamond storage pattern is used in this library
+    struct MinPriceLibStorage {
+        uint256 minMintFee;
+    }
+
+    /**
+     * @notice Update the minimum mint fee for the minter, and emit
+     * an event.
+     * @param newMinMintFee New minimum mint fee, in wei
+     */
+    function updateMinMintFee(uint256 newMinMintFee) internal {
+        MinPriceLibStorage storage minPriceLibStorage_ = s();
+        minPriceLibStorage_.minMintFee = newMinMintFee;
+        emit MinMintFeeUpdated(newMinMintFee);
+    }
+
+    /**
+     * @notice Loads the min mint fee from storage.
+     */
+    function getMinMintFee() internal view returns (uint256 minMintFee) {
+        return s().minMintFee;
+    }
+
+    /**
+     * @notice Return the storage struct for reading and writing. This library
+     * uses a diamond storage pattern when managing storage.
+     * @return storageStruct The MinPriceLibStorage struct.
+     */
+    function s()
+        internal
+        pure
+        returns (MinPriceLibStorage storage storageStruct)
+    {
+        bytes32 position = MIN_PRICE_LIB_STORAGE_POSITION;
+        assembly ("memory-safe") {
+            storageStruct.slot := position
+        }
+    }
+}

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

@@ -96,6 +96,44 @@ library SplitFundsLib {
         }
     }
 
+    /**
+     * @notice pays ETH funds to sender (if refund), with all of token price
+     * being sent to the render provider for a token purchased on project
+     * `projectId`.
+     * WARNING: This function uses msg.value and msg.sender to determine
+     * refund amounts, and therefore may not be applicable to all use cases
+     * (e.g. do not use with Dutch Auctions with on-chain settlement).
+     * @dev This function relies on msg.sender and msg.value, so it must be
+     * called directly from the contract that is receiving the payment.
+     * @dev possible DoS during splits is acknowledged, and mitigated by
+     * business practices, including end-to-end testing on mainnet, and
+     * admin-accepted artist payment addresses.
+     * @param projectId Project ID for which funds shall be split.
+     * @param pricePerTokenInWei Current price of token, in Wei.
+     * @param coreContract Address of the GenArt721CoreContract associated
+     * with the project.
+     */
+    function sendAllToRenderProviderETHRefundSender(
+        uint256 projectId,
+        uint256 pricePerTokenInWei,
+        address coreContract
+    ) internal {
+        if (msg.value > 0) {
+            // send refund to sender
+            uint256 refund = msg.value - pricePerTokenInWei;
+            if (refund > 0) {
+                (bool success_, ) = msg.sender.call{value: refund}("");
+                require(success_, "Refund failed");
+            }
+            // send remaining to render provider
+            sendAllToRenderProviderETHNoRefund({
+                projectId: projectId,
+                valueInWei: pricePerTokenInWei,
+                coreContract: coreContract
+            });
+        }
+    }
+
     /**
      * @notice Splits ETH revenues between providers, artist, and artist's
      * additional payee for revenue generated by project `projectId`.
@@ -185,6 +223,75 @@ library SplitFundsLib {
         });
     }
 
+    /**
+     * @notice Sends all revenue generated by project `projectId` to render
+     * provider.
+     * This function does NOT refund msg.sender, and does NOT use msg.value
+     * when determining the value to be split.
+     * @dev possible DoS during splits is acknowledged, and mitigated by
+     * business practices, including end-to-end testing on mainnet, and
+     * admin-accepted payment addresses.
+     * @param projectId Project ID for which funds shall be sent.
+     * @param valueInWei Value to be sent, in Wei.
+     * @param coreContract Address of the GenArt721CoreContract
+     * associated with the project.
+     */
+    function sendAllToRenderProviderETHNoRefund(
+        uint256 projectId,
+        uint256 valueInWei,
+        address coreContract
+    ) internal {
+        if (valueInWei == 0) {
+            return; // return early
+        }
+        // split funds between platforms, artist, and artist's
+        // additional payee
+        bool isEngine_ = isEngine(coreContract);
+        address payable renderProviderAddress;
+        if (isEngine_) {
+            // get engine splits
+            (
+                ,
+                renderProviderAddress,
+                ,
+                ,
+                ,
+                ,
+                ,
+
+            ) = IGenArt721CoreContractV3_Engine(coreContract)
+                .getPrimaryRevenueSplits({
+                    _projectId: projectId,
+                    _price: valueInWei
+                });
+        } else {
+            // get flagship splits
+            // @dev note that platformProviderAddress and
+            // platformProviderRevenue remain 0 for flagship
+            (
+                ,
+                // artblocks revenue
+                renderProviderAddress, // artblocks address
+                ,
+                ,
+                ,
+
+            ) = IGenArt721CoreContractV3(coreContract).getPrimaryRevenueSplits({
+                _projectId: projectId,
+                _price: valueInWei
+            });
+        }
+        require(
+            renderProviderAddress != address(0),
+            "Render Provider address not set"
+        );
+        // distribute revenue
+        // Render Provider / Art Blocks payment
+        // @dev previous conditional ensures valueInWei is non-zero
+        (bool success, ) = renderProviderAddress.call{value: valueInWei}("");
+        require(success, "Render Provider payment failed");
+    }
+
     /**
      * @notice Splits ERC20 funds between providers, artist, and artist's
      * additional payee, for a token purchased on project `projectId`.