Contract Name:
ArtistProxy
Contract Source Code:
//SPDX-License-Identifier: MIT
pragma solidity >=0.6.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IBrainDrops {
function mint(address recipient, uint _projectId) external payable returns (uint256);
function updateProjectArtistName(uint256 _projectId, string memory _projectArtistName) external;
function updateProjectDescription(uint256 _projectId, string memory _projectDescription) external;
function updateProjectWebsite(uint256 _projectId, string memory _projectWebsite) external;
function updateProjectLicense(uint256 _projectId, string memory _projectLicense) external;
function updateProjectBaseURI(uint256 _projectId, string memory _projectBaseURI) external;
function updateProjectPricePerTokenInWei(uint256 _projectId, uint256 _pricePerTokenInWei) external;
function toggleProjectIsPaused(uint256 _projectId) external;
function setProvenanceHash(uint256 _projectId, string memory provenanceHash) external;
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function isWhitelisted(address sender) external view returns (bool whitelisted);
function transferFrom(address from, address to, uint256 tokenId) external;
}
interface IDelegationRegistry {
function checkDelegateForContract(address delegate, address vault, address contract_) external returns(bool);
}
contract ArtistProxy is Ownable, ReentrancyGuard {
constructor(address _braindropsAddress) {
braindrops = IBrainDrops(_braindropsAddress);
}
IBrainDrops public braindrops;
IDelegationRegistry public delegationRegistry;
mapping(uint256 => mapping(address => bool)) public projectIdToProxyDropAddressMinted;
mapping(uint256 => mapping(uint256 => bool)) public projectIdToGenesisDropTokenMinted;
mapping(uint256 => mapping(uint256 => bool)) public projectIdToProjectSpecificHoldersTokenMinted;
mapping(uint256 => address) public projectIdToArtistAddress;
mapping(uint256 => bool) public projectIdToProjectActivated;
mapping(uint256 => bool) public projectIdToHolderActivated;
mapping(uint256 => bool) public projectIdToGenesisDropActivated;
mapping(uint256 => bool) public projectIdToProjectIsAddressMintLimited;
mapping(uint256 => uint256) public projectIdToOlderProjectId;
modifier onlyArtist(uint256 _projectId) {
require(msg.sender == projectIdToArtistAddress[_projectId], "Only artist");
_;
}
modifier onlyArtistOrOwner(uint256 _projectId) {
require(msg.sender == projectIdToArtistAddress[_projectId] || msg.sender == owner(), "Only artist or owner");
_;
}
modifier onlyAllowListed() {
require(braindrops.isWhitelisted(msg.sender), "Only allowListed");
_;
}
modifier onlyHolders(uint256 _projectId) {
require(braindrops.balanceOf(msg.sender) > 0, "Holders only");
_;
}
function setDelegationRegistry(address _registryAddress) public onlyOwner {
delegationRegistry = IDelegationRegistry(_registryAddress);
}
function setArtist(uint projectId, address artistAddress) public onlyAllowListed {
projectIdToArtistAddress[projectId] = artistAddress;
}
function updateProjectArtistName(uint256 _projectId, string memory _projectArtistName) onlyArtist(_projectId) public {
braindrops.updateProjectArtistName(_projectId, _projectArtistName);
}
function updateProjectDescription(uint256 _projectId, string memory _projectDescription) onlyArtist(_projectId) public {
braindrops.updateProjectDescription(_projectId, _projectDescription);
}
function updateProjectWebsite(uint256 _projectId, string memory _projectWebsite) onlyArtist(_projectId) public {
braindrops.updateProjectWebsite(_projectId, _projectWebsite);
}
function updateProjectLicense(uint256 _projectId, string memory _projectLicense) onlyArtist(_projectId) public {
braindrops.updateProjectLicense(_projectId, _projectLicense);
}
function updateProjectBaseURI(uint256 _projectId, string memory _projectBaseURI) onlyArtist(_projectId) public {
braindrops.updateProjectBaseURI(_projectId, _projectBaseURI);
}
function updateProjectPricePerTokenInWei(uint256 _projectId, uint256 _pricePerTokenInWei) onlyArtist(_projectId) public {
braindrops.updateProjectPricePerTokenInWei(_projectId, _pricePerTokenInWei);
}
function toggleProjectIsPaused(uint256 _projectId) public onlyArtist(_projectId) {
braindrops.toggleProjectIsPaused(_projectId);
}
function setProvenanceHash(uint256 _projectId, string memory provenanceHash) public onlyArtist(_projectId) {
braindrops.setProvenanceHash(_projectId, provenanceHash);
}
function toggleProjectIsAddressMintLimited(uint256 _projectId) public onlyArtist(_projectId) {
projectIdToProjectIsAddressMintLimited[_projectId] = !projectIdToProjectIsAddressMintLimited[_projectId];
}
function toggleProjectIsActive(uint256 _projectId) public onlyArtist(_projectId) {
projectIdToProjectActivated[_projectId] = !projectIdToProjectActivated[_projectId];
}
function toggleProjectIsHolderActive(uint256 _projectId) public onlyArtist(_projectId) {
projectIdToHolderActivated[_projectId] = !projectIdToHolderActivated[_projectId];
}
function toggleProjectIsGenesisDropActive(uint256 _projectId) public onlyArtist(_projectId) {
projectIdToGenesisDropActivated[_projectId] = !projectIdToGenesisDropActivated[_projectId];
}
function setProjectIdToOlderProjectId(uint256 _projectId, uint256 _olderProjectId) public onlyArtist(_projectId) {
projectIdToOlderProjectId[_projectId] = _olderProjectId;
}
function mintForArtistsOnly(address recipient, uint _projectId)
public
payable
onlyArtist(_projectId)
returns (uint256)
{
return braindrops.mint{value: msg.value}(recipient, _projectId);
}
function reserve(address recipient, uint _projectId, uint amount)
public
payable
onlyArtistOrOwner(_projectId)
{
uint b;
for (b = 0; b < amount; b++) {
braindrops.mint{value: (msg.value / amount)}(recipient, _projectId);
}
}
function mintForProjectSpecificHoldersOnly(address recipient, uint _projectId, uint _projectTokenId)
public
payable
nonReentrant
returns (uint256)
{
uint olderProjectId = projectIdToOlderProjectId[_projectId];
require(olderProjectId > 0, "Project must be active for project-holder specific mints");
uint _projectIdFromTokenId = (_projectTokenId - (_projectTokenId % 1000000)) / 1000000;
require(_projectIdFromTokenId == olderProjectId, "must pass in a token id from the correct project");
require(braindrops.ownerOf(_projectTokenId) == msg.sender, "sender must own token id passed in");
require(projectIdToGenesisDropTokenMinted[_projectId][_projectTokenId] == false, "token already used to mint");
projectIdToGenesisDropTokenMinted[_projectId][_projectTokenId] = true;
return braindrops.mint{value: msg.value}(recipient, _projectId);
}
function mintForGenesisDropHoldersOnly(address recipient, uint _projectId, uint _project1TokenId, uint _project2TokenId, uint _project3TokenId, address _vault)
public
payable
nonReentrant
returns (uint256)
{
address requester = msg.sender;
if (_vault != address(0)) {
bool isDelegateValid = delegationRegistry.checkDelegateForContract(msg.sender, _vault, address(braindrops));
require(isDelegateValid, "invalid delegate-vault pairing");
requester = _vault;
}
require(projectIdToGenesisDropActivated[_projectId], "Project must be active for genesis set holders");
uint _project1Id = (_project1TokenId - (_project1TokenId % 1000000)) / 1000000;
require(_project1Id == 1, "must pass in a token id from project 1");
require(projectIdToGenesisDropTokenMinted[_projectId][_project1TokenId] == false, "project 1 token already used to mint");
uint _project2Id = (_project2TokenId - (_project2TokenId % 1000000)) / 1000000;
require(_project2Id == 2, "must pass in a token id from project 2");
require(projectIdToGenesisDropTokenMinted[_projectId][_project2TokenId] == false, "project 2 token already used to mint");
uint _project3Id = (_project3TokenId - (_project3TokenId % 1000000)) / 1000000;
require(_project3Id == 3, "must pass in a token id from project 3");
require(projectIdToGenesisDropTokenMinted[_projectId][_project3TokenId] == false, "project 3 token already used to mint");
require(braindrops.ownerOf(_project1TokenId) == requester, "must own the selected token from project 1");
require(braindrops.ownerOf(_project2TokenId) == requester, "must own the selected token from project 2");
require(braindrops.ownerOf(_project3TokenId) == requester, "must own the selected token from project 3");
projectIdToGenesisDropTokenMinted[_projectId][_project1TokenId] = true;
projectIdToGenesisDropTokenMinted[_projectId][_project2TokenId] = true;
projectIdToGenesisDropTokenMinted[_projectId][_project3TokenId] = true;
return braindrops.mint{value: msg.value}(recipient, _projectId);
}
function mintForHoldersOnly(address recipient, uint _projectId)
public
payable
nonReentrant
onlyHolders(_projectId)
returns (uint256)
{
require(projectIdToHolderActivated[_projectId], "Project must be active for holders");
return braindrops.mint{value: msg.value}(recipient, _projectId);
}
function mint(address recipient, uint _projectId)
public
payable
nonReentrant
returns (uint256)
{
require(tx.origin == msg.sender, "cannot be called from another contract");
require(projectIdToProjectActivated[_projectId], "Project must be active");
if (projectIdToProjectIsAddressMintLimited[_projectId]) {
require(projectIdToProxyDropAddressMinted[_projectId][msg.sender] == false, "One mint per address");
projectIdToProxyDropAddressMinted[_projectId][msg.sender] = true;
}
return braindrops.mint{value: msg.value}(recipient, _projectId);
}
function withdraw() public onlyOwner {
uint balance = address(this).balance;
payable(msg.sender).transfer(balance);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a 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 make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}