@artblocks/contracts 0.0.1

package/contracts/legacy/GenArt721LegacyMinter.sol

@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+import "../libs/0.5.x/SafeMath.sol";
+import "../libs/0.5.x/Strings.sol";
+import "../libs/0.5.x/IERC20.sol";
+
+import "../interfaces/0.5.x/IGenArt721CoreContractV1.sol";
+import "../interfaces/0.5.x/IBonusContract.sol";
+
+pragma solidity ^0.5.0;
+
+contract GenArt721LegacyMinter {
+    using SafeMath for uint256;
+
+    IGenArt721CoreContractV1 public artblocksContract;
+
+    uint256 constant ONE_MILLION = 1_000_000;
+
+    mapping(uint256 => bool) public projectIdToBonus;
+    mapping(uint256 => address) public projectIdToBonusContractAddress;
+    mapping(uint256 => bool) public contractFilterProject;
+    mapping(address => mapping(uint256 => uint256)) public projectMintCounter;
+    mapping(uint256 => uint256) public projectMintLimit;
+    mapping(uint256 => bool) public projectMaxHasBeenInvoked;
+    mapping(uint256 => uint256) public projectMaxInvocations;
+
+    constructor(address _genArt721Address) public {
+        artblocksContract = IGenArt721CoreContractV1(_genArt721Address);
+    }
+
+    function getYourBalanceOfProjectERC20(
+        uint256 _projectId
+    ) public view returns (uint256) {
+        uint256 balance = IERC20(
+            artblocksContract.projectIdToCurrencyAddress(_projectId)
+        ).balanceOf(msg.sender);
+        return balance;
+    }
+
+    function checkYourAllowanceOfProjectERC20(
+        uint256 _projectId
+    ) public view returns (uint256) {
+        uint256 remaining = IERC20(
+            artblocksContract.projectIdToCurrencyAddress(_projectId)
+        ).allowance(msg.sender, address(this));
+        return remaining;
+    }
+
+    function setProjectMintLimit(uint256 _projectId, uint8 _limit) public {
+        require(
+            artblocksContract.isWhitelisted(msg.sender),
+            "can only be set by admin"
+        );
+        projectMintLimit[_projectId] = _limit;
+    }
+
+    function setProjectMaxInvocations(uint256 _projectId) public {
+        require(
+            artblocksContract.isWhitelisted(msg.sender),
+            "can only be set by admin"
+        );
+        uint256 maxInvocations;
+        uint256 invocations;
+        (, , invocations, maxInvocations, , , , , ) = artblocksContract
+            .projectTokenInfo(_projectId);
+        projectMaxInvocations[_projectId] = maxInvocations;
+        if (invocations < maxInvocations) {
+            projectMaxHasBeenInvoked[_projectId] = false;
+        }
+    }
+
+    function toggleContractFilter(uint256 _projectId) public {
+        require(
+            artblocksContract.isWhitelisted(msg.sender),
+            "can only be set by admin"
+        );
+        contractFilterProject[_projectId] = !contractFilterProject[_projectId];
+    }
+
+    function artistToggleBonus(uint256 _projectId) public {
+        require(
+            msg.sender ==
+                artblocksContract.projectIdToArtistAddress(_projectId),
+            "can only be set by artist"
+        );
+        projectIdToBonus[_projectId] = !projectIdToBonus[_projectId];
+    }
+
+    function artistSetBonusContractAddress(
+        uint256 _projectId,
+        address _bonusContractAddress
+    ) public {
+        require(
+            msg.sender ==
+                artblocksContract.projectIdToArtistAddress(_projectId),
+            "can only be set by artist"
+        );
+        projectIdToBonusContractAddress[_projectId] = _bonusContractAddress;
+    }
+
+    function purchase(
+        uint256 _projectId
+    ) public payable returns (uint256 _tokenId) {
+        return purchaseTo(msg.sender, _projectId);
+    }
+
+    //removed public and payable
+    function purchaseTo(
+        address _to,
+        uint256 _projectId
+    ) private returns (uint256 _tokenId) {
+        require(
+            !projectMaxHasBeenInvoked[_projectId],
+            "Maximum number of invocations reached"
+        );
+        if (
+            keccak256(
+                abi.encodePacked(
+                    artblocksContract.projectIdToCurrencySymbol(_projectId)
+                )
+            ) != keccak256(abi.encodePacked("ETH"))
+        ) {
+            require(
+                msg.value == 0,
+                "this project accepts a different currency and cannot accept ETH"
+            );
+            require(
+                IERC20(artblocksContract.projectIdToCurrencyAddress(_projectId))
+                    .allowance(msg.sender, address(this)) >=
+                    artblocksContract.projectIdToPricePerTokenInWei(_projectId),
+                "Insufficient Funds Approved for TX"
+            );
+            require(
+                IERC20(artblocksContract.projectIdToCurrencyAddress(_projectId))
+                    .balanceOf(msg.sender) >=
+                    artblocksContract.projectIdToPricePerTokenInWei(_projectId),
+                "Insufficient balance."
+            );
+            _splitFundsERC20(_projectId);
+        } else {
+            require(
+                msg.value >=
+                    artblocksContract.projectIdToPricePerTokenInWei(_projectId),
+                "Must send minimum value to mint!"
+            );
+            _splitFundsETH(_projectId);
+        }
+
+        // if contract filter is active prevent calls from another contract
+        if (contractFilterProject[_projectId])
+            require(msg.sender == tx.origin, "No Contract Buys");
+
+        // limit mints per address by project
+        if (projectMintLimit[_projectId] > 0) {
+            require(
+                projectMintCounter[msg.sender][_projectId] <
+                    projectMintLimit[_projectId],
+                "Reached minting limit"
+            );
+            projectMintCounter[msg.sender][_projectId]++;
+        }
+
+        uint256 tokenId = artblocksContract.mint(_to, _projectId, msg.sender);
+        // What if this overflows, since default value of uint256 is 0?
+        // that is intended, so that by default the minter allows infinite transactions,
+        // allowing the artblocks contract to stop minting
+        // uint256 tokenInvocation = tokenId % ONE_MILLION;
+        if (tokenId % ONE_MILLION == projectMaxInvocations[_projectId] - 1) {
+            projectMaxHasBeenInvoked[_projectId] = true;
+        }
+
+        if (projectIdToBonus[_projectId]) {
+            require(
+                IBonusContract(projectIdToBonusContractAddress[_projectId])
+                    .bonusIsActive(),
+                "bonus must be active"
+            );
+            IBonusContract(projectIdToBonusContractAddress[_projectId])
+                .triggerBonus(msg.sender);
+        }
+
+        return tokenId;
+    }
+
+    function _splitFundsETH(uint256 _projectId) internal {
+        if (msg.value > 0) {
+            uint256 pricePerTokenInWei = artblocksContract
+                .projectIdToPricePerTokenInWei(_projectId);
+            uint256 refund = msg.value.sub(
+                artblocksContract.projectIdToPricePerTokenInWei(_projectId)
+            );
+            if (refund > 0) {
+                msg.sender.transfer(refund);
+            }
+            uint256 foundationAmount = pricePerTokenInWei.div(100).mul(
+                artblocksContract.artblocksPercentage()
+            );
+            if (foundationAmount > 0) {
+                artblocksContract.artblocksAddress().transfer(foundationAmount);
+            }
+            uint256 projectFunds = pricePerTokenInWei.sub(foundationAmount);
+            uint256 additionalPayeeAmount;
+            if (
+                artblocksContract.projectIdToAdditionalPayeePercentage(
+                    _projectId
+                ) > 0
+            ) {
+                additionalPayeeAmount = projectFunds.div(100).mul(
+                    artblocksContract.projectIdToAdditionalPayeePercentage(
+                        _projectId
+                    )
+                );
+                if (additionalPayeeAmount > 0) {
+                    artblocksContract
+                        .projectIdToAdditionalPayee(_projectId)
+                        .transfer(additionalPayeeAmount);
+                }
+            }
+            uint256 creatorFunds = projectFunds.sub(additionalPayeeAmount);
+            if (creatorFunds > 0) {
+                artblocksContract.projectIdToArtistAddress(_projectId).transfer(
+                    creatorFunds
+                );
+            }
+        }
+    }
+
+    function _splitFundsERC20(uint256 _projectId) internal {
+        uint256 pricePerTokenInWei = artblocksContract
+            .projectIdToPricePerTokenInWei(_projectId);
+        uint256 foundationAmount = pricePerTokenInWei.div(100).mul(
+            artblocksContract.artblocksPercentage()
+        );
+        if (foundationAmount > 0) {
+            IERC20(artblocksContract.projectIdToCurrencyAddress(_projectId))
+                .transferFrom(
+                    msg.sender,
+                    artblocksContract.artblocksAddress(),
+                    foundationAmount
+                );
+        }
+        uint256 projectFunds = pricePerTokenInWei.sub(foundationAmount);
+        uint256 additionalPayeeAmount;
+        if (
+            artblocksContract.projectIdToAdditionalPayeePercentage(_projectId) >
+            0
+        ) {
+            additionalPayeeAmount = projectFunds.div(100).mul(
+                artblocksContract.projectIdToAdditionalPayeePercentage(
+                    _projectId
+                )
+            );
+            if (additionalPayeeAmount > 0) {
+                IERC20(artblocksContract.projectIdToCurrencyAddress(_projectId))
+                    .transferFrom(
+                        msg.sender,
+                        artblocksContract.projectIdToAdditionalPayee(
+                            _projectId
+                        ),
+                        additionalPayeeAmount
+                    );
+            }
+        }
+        uint256 creatorFunds = projectFunds.sub(additionalPayeeAmount);
+        if (creatorFunds > 0) {
+            IERC20(artblocksContract.projectIdToCurrencyAddress(_projectId))
+                .transferFrom(
+                    msg.sender,
+                    artblocksContract.projectIdToArtistAddress(_projectId),
+                    creatorFunds
+                );
+        }
+    }
+}

package/contracts/libs/0.5.x/CustomERC721Metadata.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+// **Please Note**: This library is not necessary for ^0.8.0 contracts and thus
+//                  only exists for posterity reasons for compatibility with
+//                  existing already-deployed ^0.5.0 PBAB contracts.
+
+pragma solidity ^0.5.0;
+
+import "@openzeppelin-0.5/contracts/introspection/ERC165.sol";
+import "@openzeppelin-0.5/contracts/token/ERC721/ERC721.sol";
+import "@openzeppelin-0.5/contracts/token/ERC721/ERC721Enumerable.sol";
+
+/**
+ * ERC721 base contract without the concept of tokenUri as this is managed by the parent
+ */
+contract CustomERC721Metadata is ERC165, ERC721, ERC721Enumerable {
+    // Token name
+    string private _name;
+
+    // Token symbol
+    string private _symbol;
+
+    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
+
+    /**
+     * @dev Constructor function
+     */
+    constructor(string memory name, string memory symbol) public {
+        _name = name;
+        _symbol = symbol;
+
+        // register the supported interfaces to conform to ERC721 via ERC165
+        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
+    }
+
+    /**
+     * @dev Gets the token name
+     * @return string representing the token name
+     */
+    function name() external view returns (string memory) {
+        return _name;
+    }
+
+    /**
+     * @dev Gets the token symbol
+     * @return string representing the token symbol
+     */
+    function symbol() external view returns (string memory) {
+        return _symbol;
+    }
+}

package/contracts/libs/0.5.x/IERC20.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)
+
+// **Please Note**: This library is not necessary for ^0.8.0 contracts and thus
+//                  only exists for posterity reasons for compatibility with
+//                  existing already-deployed ^0.5.0 PBAB contracts.
+
+pragma solidity ^0.5.0;
+
+/**
+ * @dev Interface of the ERC20 standard as defined in the EIP.
+ */
+interface IERC20 {
+    /**
+     * @dev Returns the amount of tokens in existence.
+     */
+    function totalSupply() external view returns (uint256);
+
+    /**
+     * @dev Returns the amount of tokens owned by `account`.
+     */
+    function balanceOf(address account) external view returns (uint256);
+
+    /**
+     * @dev Moves `amount` tokens from the caller's account to `recipient`.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transfer(
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    /**
+     * @dev Returns the remaining number of tokens that `spender` will be
+     * allowed to spend on behalf of `owner` through {transferFrom}. This is
+     * zero by default.
+     *
+     * This value changes when {approve} or {transferFrom} are called.
+     */
+    function allowance(
+        address owner,
+        address spender
+    ) external view returns (uint256);
+
+    /**
+     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * IMPORTANT: Beware that changing an allowance with this method brings the risk
+     * that someone may use both the old and the new allowance by unfortunate
+     * transaction ordering. One possible solution to mitigate this race
+     * condition is to first reduce the spender's allowance to 0 and set the
+     * desired value afterwards:
+     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+     *
+     * Emits an {Approval} event.
+     */
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    /**
+     * @dev Moves `amount` tokens from `sender` to `recipient` using the
+     * allowance mechanism. `amount` is then deducted from the caller's
+     * allowance.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    /**
+     * @dev Emitted when `value` tokens are moved from one account (`from`) to
+     * another (`to`).
+     *
+     * Note that `value` may be zero.
+     */
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    /**
+     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
+     * a call to {approve}. `value` is the new allowance.
+     */
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+}

package/contracts/libs/0.5.x/SafeMath.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+// File: openzeppelin-solidity/contracts/math/SafeMath.sol
+
+// **Please Note**: This library is not necessary for ^0.8.0 contracts and thus
+//                  only exists for posterity reasons for compatibility with
+//                  existing already-deployed ^0.5.0 PBAB contracts.
+
+pragma solidity ^0.5.0;
+
+/**
+ * @dev Wrappers over Solidity's arithmetic operations with added overflow
+ * checks.
+ *
+ * Arithmetic operations in Solidity wrap on overflow. This can easily result
+ * in bugs, because programmers usually assume that an overflow raises an
+ * error, which is the standard behavior in high level programming languages.
+ * `SafeMath` restores this intuition by reverting the transaction when an
+ * operation overflows.
+ *
+ * Using this library instead of the unchecked operations eliminates an entire
+ * class of bugs, so it's recommended to use it always.
+ */
+library SafeMath {
+    /**
+     * @dev Returns the addition of two unsigned integers, reverting on
+     * overflow.
+     *
+     * Counterpart to Solidity's `+` operator.
+     *
+     * Requirements:
+     * - Addition cannot overflow.
+     */
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "SafeMath: addition overflow");
+
+        return c;
+    }
+
+    /**
+     * @dev Returns the subtraction of two unsigned integers, reverting on
+     * overflow (when the result is negative).
+     *
+     * Counterpart to Solidity's `-` operator.
+     *
+     * Requirements:
+     * - Subtraction cannot overflow.
+     */
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        require(b <= a, "SafeMath: subtraction overflow");
+        uint256 c = a - b;
+
+        return c;
+    }
+
+    /**
+     * @dev Returns the multiplication of two unsigned integers, reverting on
+     * overflow.
+     *
+     * Counterpart to Solidity's `*` operator.
+     *
+     * Requirements:
+     * - Multiplication cannot overflow.
+     */
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
+        // benefit is lost if 'b' is also tested.
+        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
+        if (a == 0) {
+            return 0;
+        }
+
+        uint256 c = a * b;
+        require(c / a == b, "SafeMath: multiplication overflow");
+
+        return c;
+    }
+
+    /**
+     * @dev Returns the integer division of two unsigned integers. Reverts on
+     * division by zero. The result is rounded towards zero.
+     *
+     * Counterpart to Solidity's `/` operator. Note: this function uses a
+     * `revert` opcode (which leaves remaining gas untouched) while Solidity
+     * uses an invalid opcode to revert (consuming all remaining gas).
+     *
+     * Requirements:
+     * - The divisor cannot be zero.
+     */
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        // Solidity only automatically asserts when dividing by 0
+        require(b > 0, "SafeMath: division by zero");
+        uint256 c = a / b;
+        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+
+        return c;
+    }
+}

package/contracts/libs/0.5.x/Strings.sol

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+// File: contracts/Strings.sol
+// Source: https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
+
+// **Please Note**: This library is not necessary for ^0.8.0 contracts and thus
+//                  only exists for posterity reasons for compatibility with
+//                  existing already-deployed ^0.5.0 PBAB contracts.
+
+pragma solidity ^0.5.0;
+
+library Strings {
+    function strConcat(
+        string memory _a,
+        string memory _b
+    ) internal pure returns (string memory _concatenatedString) {
+        return strConcat(_a, _b, "", "", "");
+    }
+
+    function strConcat(
+        string memory _a,
+        string memory _b,
+        string memory _c
+    ) internal pure returns (string memory _concatenatedString) {
+        return strConcat(_a, _b, _c, "", "");
+    }
+
+    function strConcat(
+        string memory _a,
+        string memory _b,
+        string memory _c,
+        string memory _d
+    ) internal pure returns (string memory _concatenatedString) {
+        return strConcat(_a, _b, _c, _d, "");
+    }
+
+    function strConcat(
+        string memory _a,
+        string memory _b,
+        string memory _c,
+        string memory _d,
+        string memory _e
+    ) internal pure returns (string memory _concatenatedString) {
+        bytes memory _ba = bytes(_a);
+        bytes memory _bb = bytes(_b);
+        bytes memory _bc = bytes(_c);
+        bytes memory _bd = bytes(_d);
+        bytes memory _be = bytes(_e);
+        string memory abcde = new string(
+            _ba.length + _bb.length + _bc.length + _bd.length + _be.length
+        );
+        bytes memory babcde = bytes(abcde);
+        uint256 k = 0;
+        uint256 i = 0;
+        for (i = 0; i < _ba.length; i++) {
+            babcde[k++] = _ba[i];
+        }
+        for (i = 0; i < _bb.length; i++) {
+            babcde[k++] = _bb[i];
+        }
+        for (i = 0; i < _bc.length; i++) {
+            babcde[k++] = _bc[i];
+        }
+        for (i = 0; i < _bd.length; i++) {
+            babcde[k++] = _bd[i];
+        }
+        for (i = 0; i < _be.length; i++) {
+            babcde[k++] = _be[i];
+        }
+        return string(babcde);
+    }
+
+    function uint2str(
+        uint256 _i
+    ) internal pure returns (string memory _uintAsString) {
+        if (_i == 0) {
+            return "0";
+        }
+        uint256 j = _i;
+        uint256 len;
+        while (j != 0) {
+            len++;
+            j /= 10;
+        }
+        bytes memory bstr = new bytes(len);
+        uint256 k = len - 1;
+        while (_i != 0) {
+            bstr[k--] = bytes1(uint8(48 + (_i % 10)));
+            _i /= 10;
+        }
+        return string(bstr);
+    }
+}