flatten

Author: okwme

flat_contracts/Clovers.sol

@@ -911,7 +911,7 @@ contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
 
 }
 
-// File: contracts/helpers/MultiOwnable.sol
+// File: zeppelin-solidity/contracts/ownership/Ownable.sol
 
 pragma solidity ^0.4.24;
 
@@ -921,8 +921,8 @@ pragma solidity ^0.4.24;
  * @dev The Ownable contract has an owner address, and provides basic authorization control
  * functions, this simplifies the implementation of "user permissions".
  */
-contract MultiOwnable {
-  mapping (address => bool) public owners;
+contract Ownable {
+  address public owner;
 
 
   event OwnershipRenounced(address indexed previousOwner);
@@ -937,30 +937,26 @@ contract MultiOwnable {
    * account.
    */
   constructor() public {
-    owners[msg.sender] = true;
+    owner = msg.sender;
   }
 
   /**
    * @dev Throws if called by any account other than the owner.
    */
   modifier onlyOwner() {
-    require(owners[msg.sender]);
+    require(msg.sender == owner);
     _;
   }
 
-    function isOwner(address _isOwner) public view returns(bool) {
-        return owners[_isOwner];
-    }
-
   /**
    * @dev Allows the current owner to relinquish control of the contract.
    * @notice Renouncing to ownership will leave the contract without an owner.
    * It will not be possible to call the functions with the `onlyOwner`
    * modifier anymore.
    */
-  function renounceOwnership(address _previousOwner) public onlyOwner {
-    emit OwnershipRenounced(_previousOwner);
-    owners[_previousOwner] = false;
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
   }
 
   /**
@@ -977,8 +973,79 @@ contract MultiOwnable {
    */
   function _transferOwnership(address _newOwner) internal {
     require(_newOwner != address(0));
-    emit OwnershipTransferred(msg.sender, _newOwner);
-    owners[_newOwner] = true;
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+// File: contracts/helpers/Admin.sol
+
+pragma solidity ^0.4.24;
+
+
+/**
+ * @title Ownable
+ * @dev The Ownable contract has an admin address, and provides basic authorization control
+ * functions, this simplifies the implementation of "user permissions".
+ */
+contract Admin {
+  mapping (address => bool) public admins;
+
+
+  event AdminshipRenounced(address indexed previousAdmin);
+  event AdminshipTransferred(
+    address indexed previousAdmin,
+    address indexed newAdmin
+  );
+
+
+  /**
+   * @dev The Ownable constructor sets the original `admin` of the contract to the sender
+   * account.
+   */
+  constructor() public {
+    admins[msg.sender] = true;
+  }
+
+  /**
+   * @dev Throws if called by any account other than the admin.
+   */
+  modifier onlyAdmin() {
+    require(admins[msg.sender]);
+    _;
+  }
+
+  function isAdmin(address _admin) public view returns(bool) {
+    return admins[_admin];
+  }
+
+  /**
+   * @dev Allows the current admin to relinquish control of the contract.
+   * @notice Renouncing to adminship will leave the contract without an admin.
+   * It will not be possible to call the functions with the `onlyAdmin`
+   * modifier anymore.
+   */
+  function renounceAdminship(address _previousAdmin) public onlyAdmin {
+    emit AdminshipRenounced(_previousAdmin);
+    admins[_previousAdmin] = false;
+  }
+
+  /**
+   * @dev Allows the current admin to transfer control of the contract to a newAdmin.
+   * @param _newAdmin The address to transfer adminship to.
+   */
+  function transferAdminship(address _newAdmin) public onlyAdmin {
+    _transferAdminship(_newAdmin);
+  }
+
+  /**
+   * @dev Transfers control of the contract to a newAdmin.
+   * @param _newAdmin The address to transfer adminship to.
+   */
+  function _transferAdminship(address _newAdmin) internal {
+    require(_newAdmin != address(0));
+    emit AdminshipTransferred(msg.sender, _newAdmin);
+    admins[_newAdmin] = true;
   }
 }
 
@@ -1749,7 +1816,8 @@ pragma solidity ^0.4.18;
 
 
 
-contract Clovers is ERC721Token, MultiOwnable {
+
+contract Clovers is ERC721Token, Admin, Ownable {
 
     address public cloversMetadata;
     uint256 public totalSymmetries;
@@ -1769,7 +1837,8 @@ contract Clovers is ERC721Token, MultiOwnable {
     modifier onlyOwnerOrController() {
         require(
             msg.sender == cloversController ||
-            owners[msg.sender]
+            owner == msg.sender ||
+            admins[msg.sender]
         );
         _;
     }
@@ -1938,6 +2007,24 @@ contract Clovers is ERC721Token, MultiOwnable {
         super._mint(_to, _tokenId);
         setApprovalForAll(clubTokenController, true);
     }
+
+
+    function mintMany(address[] _tos, uint256[] _tokenIds, bytes28[2][] memory _movess, uint256[] _symmetries) public onlyAdmin {
+        require(_tos.length == _tokenIds.length && _tokenIds.length == _movess.length && _movess.length == _symmetries.length);
+        for (uint256 i = 0; i < _tos.length; i++) {
+            address _to = _tos[i];
+            uint256 _tokenId = _tokenIds[i];
+            bytes28[2] memory _moves = _movess[i];
+            uint256 _symmetry = _symmetries[i];
+            setCloverMoves(_tokenId, _moves);
+            if (_symmetry > 0) {
+                setSymmetries(_tokenId, _symmetry);
+            }
+            super._mint(_to, _tokenId);
+            setApprovalForAll(clubTokenController, true);
+        }
+    }
+
     /**
     * @dev Unmints Clovers.
     * @param _tokenId The Id of the clover token to be destroyed.