Contract 0x31d4C5be1082A88F2ABAFeA549B6C189C2cf057F 1

 

Contract Overview

Aether: AETH Token
Balance:
0.‍55 Ether

EtherValue:
$1,042.91 (@ $1,896.20/ETH)

Token:
Txn Hash
Method
Block
From
To
Value
0x7588e27553e68fdb0db01fe220a1cd5edb2aad77935d9570b7f9bb543bc2fda0Approve153082712022-08-09 13:30:222 days 4 hrs ago0x86c8ff725bca6a2d678dfba373832e5211b0ab1b IN  Aether: AETH Token0 Ether0.‍00080061 25.‍93247237
0xbb024cea42ebfb144a72e16ce149077ea293779cef28c26be8a1f216314807d4Create Sale Auct...153074412022-08-09 10:23:322 days 7 hrs ago0x2f8b20fff55b8439cd9ef9acbeaf911ad3bd61f3 IN  Aether: AETH Token0 Ether0.‍00235949 19.‍98336789
0x6f300beaa110ff0d865e0253377f4886df4a3cd12c31a8628b8cde885a203dd3Approve153074252022-08-09 10:19:332 days 7 hrs ago0x2f8b20fff55b8439cd9ef9acbeaf911ad3bd61f3 IN  Aether: AETH Token0 Ether0.‍0006803 22.‍04425845
0x836e891b90d693fa3f21aab77dd88e0af53b31b474534a092eb73d3ffd5297e6Approve153074222022-08-09 10:19:022 days 7 hrs ago0x2f8b20fff55b8439cd9ef9acbeaf911ad3bd61f3 IN  Aether: AETH Token0 Ether0.‍00085294 25.‍33926214
0x4c6cbbaf8c1e4c4bc3e847d82556b9f324fd2af52ca8747bd3718d23c49eb292Approve153045012022-08-08 23:19:272 days 18 hrs ago0x190378d08d82b3dda38f14a2de5eaa405397c660 IN  Aether: AETH Token0 Ether0.‍00051982 16.‍79185757
0x590205caf07cc675eed7bae298cde43310918812f21b27ccabd9ccd23adecc7bApprove153045012022-08-08 23:19:272 days 18 hrs ago0x190378d08d82b3dda38f14a2de5eaa405397c660 IN  Aether: AETH Token0 Ether0.‍00051982 16.‍79185757
0x694eb071e5e927268244a3e4eb1c079bf4a4ec176925438701d3c1d0fa39df05Approve153044952022-08-08 23:18:102 days 18 hrs ago0x190378d08d82b3dda38f14a2de5eaa405397c660 IN  Aether: AETH Token0 Ether0.‍00053487 17.‍27812912
0xdd5a85763352606bcd3a295b5298150cff14c5620fa7ef2f607057c6c09eaffcApprove153044952022-08-08 23:18:102 days 18 hrs ago0x190378d08d82b3dda38f14a2de5eaa405397c660 IN  Aether: AETH Token0 Ether0.‍00053487 17.‍27812912
0x86aaa86ece1772f26df7c663a8f94cdf590d5be4e3f56d9984f9af2d7ff2e9d0Approve153021392022-08-08 14:37:153 days 3 hrs ago0x86c8ff725bca6a2d678dfba373832e5211b0ab1b IN  Aether: AETH Token0 Ether0.‍00057207 16.‍9892294
0xe9c2c944dbe9bf7e22a6af97e22c4e687a5810308e1c87431247ea16e4e0e840Approve153018202022-08-08 13:26:323 days 4 hrs ago0xaa1ac9cd61344161a0e264095c93a78af5144dfe IN  Aether: AETH Token0 Ether0.‍00055572 16.‍50343848
0x5c8810a8d31ddd35dc9126a5f19064efa9f0b9873046ee285aef2fc0e96e3be2Approve153018152022-08-08 13:25:003 days 4 hrs ago0xaa1ac9cd61344161a0e264095c93a78af5144dfe IN  Aether: AETH Token0 Ether0.‍00041816 13.‍54465525
0x0cf6ec89b9ee4e182c43526514d81c881f23299400afd84a3550989a07925fc4Approve153018042022-08-08 13:22:413 days 4 hrs ago0xaa1ac9cd61344161a0e264095c93a78af5144dfe IN  Aether: AETH Token0 Ether0.‍00045857 13.‍6184252
0xc677e1b4e9ab415ccb7f5671f150bb2089d20fc3034cb38a093b78b0ea7cb15fApprove152970432022-08-07 19:16:403 days 22 hrs ago0xacd65b8e9d50128780a114a16d8e9870e19c82c3 IN  Aether: AETH Token0 Ether0.‍0003970511.‍79143792
0xd5acbb65c302b3f8f307eb2baeaac53d55d340252131282ba40092870f1c42b6Approve152945782022-08-07 10:20:164 days 7 hrs agoENS Name defirat.eth IN  Aether: AETH Token0 Ether0.‍00018056 5.‍36233049
0x507818fca2f4d73270f947b38ef60f7760092ccf53fcf4b7b42d40261c5e9e8dApprove152938692022-08-07 7:41:004 days 10 hrs ago0x8c00ef3116404b64475c4bd59f0ed7ae23302930 IN  Aether: AETH Token0 Ether0.‍00014643 4.‍34883329
0x32906312ef9418d4c930943a67905ea4e849a6202b3f59fb3213b480d0395661Approve152921832022-08-07 1:14:424 days 16 hrs agoENS Name liteliger.eth IN  Aether: AETH Token0 Ether0.‍00028482 5.‍60979067
0xf82630f0c9df3ce3159af0a92fd64619c06fa1f0ef6b00278c141187c5a1dd15Approve152900432022-08-06 17:26:305 days 42 mins ago0xcb482005596f52839ae4505d73164027ad103376 IN  Aether: AETH Token0 Ether0.‍00106599 31.‍65725197
0x998b52ca85d3c863c72709b86fca760092d9a94d523087bc01347e16d591d73eApprove152898242022-08-06 16:41:185 days 1 hr agoENS Name aether-city.eth IN  Aether: AETH Token0 Ether0.‍00055934 18.‍06846051
0xd2a898f7af59be3c86b792de1ed78c8909129de0ee83514b836be50ab76564bcApprove152898142022-08-06 16:38:575 days 1 hr agoENS Name aether-city.eth IN  Aether: AETH Token0 Ether0.‍00094457 18.‍57761946
0x892aef18e51843afcc58d1244e9d15eb406df17fb6b500ae5ed94ef0163315e0Approve152898142022-08-06 16:38:575 days 1 hr agoENS Name aether-city.eth IN  Aether: AETH Token0 Ether0.‍00094457 18.‍57761946
0x368927a3240b0ecb958ed776d926f8711b0076b0e60a7d8c403ff6143f4f984bApprove152898142022-08-06 16:38:575 days 1 hr agoENS Name aether-city.eth IN  Aether: AETH Token0 Ether0.‍00094457 18.‍57761946
0x30d07097827bb157487e6d14e36ec11dfa9b973662b566ced2978bc4ca72e29cApprove152896842022-08-06 16:06:135 days 2 hrs ago0xf0ab5ed4e9508fa4274e26e3cf081abf49bf67a7 IN  Aether: AETH Token0 Ether0.‍00045698 13.‍57130923
0x565620c13adfa3517d44c5607f6dc1cd7745eb375e4aec5332307cae7f334722Approve152841532022-08-05 19:14:005 days 22 hrs ago0x8c2b9fe4f17f4be206deb6e58ef2701080cf9bf3 IN  Aether: AETH Token0 Ether0.‍00055081 17.‍84137177
0xa348bb94397bd2ea88b57a927e71a50625d46e5b6b2cb19f85c25cd2841ac5dbApprove152841502022-08-05 19:13:165 days 22 hrs ago0x8c2b9fe4f17f4be206deb6e58ef2701080cf9bf3 IN  Aether: AETH Token0 Ether0.‍00049984 16.‍19048339
0xdeb1e89fa221f6cf11dd5465d4a5cb91121b30f788408a22e2edbead88b6aee9Approve152841402022-08-05 19:11:335 days 22 hrs ago0x8c2b9fe4f17f4be206deb6e58ef2701080cf9bf3 IN  Aether: AETH Token0 Ether0.‍00073021 21.‍68533932
[ Download CSV Export 

OVERVIEW

Launched in March 2018, Aether is the first metaverse built on NFT (ERC721) standards.

Latest 5 internal transactions
Parent Txn Hash Block From To Value
0xc2e6fb86f8add723cbceaf9d259b160cd6d92af6c73b1e780d910d63dc6aa0a3132867192021-09-24 5:50:40321 days 12 hrs ago Aether: AETH TokenAether: Deployer2.‍56955 Ether
0xe849e3f9842740b7f2529c3e88f564e08d458b5f4c2e2f2f2b56ab2737e13053132867172021-09-24 5:50:02321 days 12 hrs ago 0x6e9d4b330aad2f414fa7ae1074afa266b6469364 Aether: AETH Token0.‍86955 Ether
0x82b8d8680b5f7449852368e75b3f8936dcfa974b59d2d1de0af803767f141aaf132055772021-09-11 16:39:11334 days 1 hr ago Aether: AETH TokenAether: Deployer2.‍65 Ether
0x70f7d63714ec676875b453d94719cf071f47711eeb4dc9eede937c539a7e58f269539002018-12-26 3:13:101324 days 14 hrs ago Aether: AETH TokenAether: Deployer2.‍26 Ether
0xa0207f99ea4e2e27066207a27794728076d3a965c69932772cafc113d29c58ee69538502018-12-26 3:03:511324 days 15 hrs ago 0x6e9d4b330aad2f414fa7ae1074afa266b6469364 Aether: AETH Token0.‍125 Ether
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
AetherCore

Compiler Version
v0.4.21+commit.dfe3193c

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2018-03-11
*/

pragma solidity ^0.4.18;

// File: contracts-origin/AetherAccessControl.sol

/// @title A facet of AetherCore that manages special access privileges.
/// @dev See the AetherCore contract documentation to understand how the various contract facets are arranged.
contract AetherAccessControl {
    // This facet controls access control for Laputa. There are four roles managed here:
    //
    //     - The CEO: The CEO can reassign other roles and change the addresses of our dependent smart
    //         contracts. It is also the only role that can unpause the smart contract. It is initially
    //         set to the address that created the smart contract in the AetherCore constructor.
    //
    //     - The CFO: The CFO can withdraw funds from AetherCore and its auction contracts.
    //
    //     - The COO: The COO can release properties to auction.
    //
    // It should be noted that these roles are distinct without overlap in their access abilities, the
    // abilities listed for each role above are exhaustive. In particular, while the CEO can assign any
    // address to any role, the CEO address itself doesn't have the ability to act in those roles. This
    // restriction is intentional so that we aren't tempted to use the CEO address frequently out of
    // convenience. The less we use an address, the less likely it is that we somehow compromise the
    // account.

    /// @dev Emited when contract is upgraded - See README.md for updgrade plan
    event ContractUpgrade(address newContract);

    // The addresses of the accounts (or contracts) that can execute actions within each roles.
    address public ceoAddress;
    address public cfoAddress;
    address public cooAddress;

    // @dev Keeps track whether the contract is paused. When that is true, most actions are blocked
    bool public paused = false;

    /// @dev Access modifier for CEO-only functionality
    modifier onlyCEO() {
        require(msg.sender == ceoAddress);
        _;
    }

    /// @dev Access modifier for CFO-only functionality
    modifier onlyCFO() {
        require(msg.sender == cfoAddress);
        _;
    }

    /// @dev Access modifier for COO-only functionality
    modifier onlyCOO() {
        require(msg.sender == cooAddress);
        _;
    }

    modifier onlyCLevel() {
        require(
            msg.sender == cooAddress ||
            msg.sender == ceoAddress ||
            msg.sender == cfoAddress
        );
        _;
    }

    /// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
    /// @param _newCEO The address of the new CEO
    function setCEO(address _newCEO) public onlyCEO {
        require(_newCEO != address(0));

        ceoAddress = _newCEO;
    }

    /// @dev Assigns a new address to act as the CFO. Only available to the current CEO.
    /// @param _newCFO The address of the new CFO
    function setCFO(address _newCFO) public onlyCEO {
        require(_newCFO != address(0));

        cfoAddress = _newCFO;
    }

    /// @dev Assigns a new address to act as the COO. Only available to the current CEO.
    /// @param _newCOO The address of the new COO
    function setCOO(address _newCOO) public onlyCEO {
        require(_newCOO != address(0));

        cooAddress = _newCOO;
    }

    function withdrawBalance() external onlyCFO {
        cfoAddress.transfer(this.balance);
    }


    /*** Pausable functionality adapted from OpenZeppelin ***/

    /// @dev Modifier to allow actions only when the contract IS NOT paused
    modifier whenNotPaused() {
        require(!paused);
        _;
    }

    /// @dev Modifier to allow actions only when the contract IS paused
    modifier whenPaused {
        require(paused);
        _;
    }

    /// @dev Called by any "C-level" role to pause the contract. Used only when
    ///  a bug or exploit is detected and we need to limit damage.
    function pause() public onlyCLevel whenNotPaused {
        paused = true;
    }

    /// @dev Unpauses the smart contract. Can only be called by the CEO, since
    ///  one reason we may pause the contract is when CFO or COO accounts are
    ///  compromised.
    function unpause() public onlyCEO whenPaused {
        // can't unpause if contract was upgraded
        paused = false;
    }
}

// File: contracts-origin/AetherBase.sol

/// @title Base contract for Aether. Holds all common structs, events and base variables.
/// @author Project Aether (https://www.aether.city)
/// @dev See the PropertyCore contract documentation to understand how the various contract facets are arranged.
contract AetherBase is AetherAccessControl {
    /*** EVENTS ***/

    /// @dev The Construct event is fired whenever a property updates.
    event Construct (
      address indexed owner,
      uint256 propertyId,
      PropertyClass class,
      uint8 x,
      uint8 y,
      uint8 z,
      uint8 dx,
      uint8 dz,
      string data
    );

    /// @dev Transfer event as defined in current draft of ERC721. Emitted every
    ///  time a property ownership is assigned.
    event Transfer(
      address indexed from,
      address indexed to,
      uint256 indexed tokenId
    );

    /*** DATA ***/

    enum PropertyClass { DISTRICT, BUILDING, UNIT }

    /// @dev The main Property struct. Every property in Aether is represented
    ///  by a variant of this structure.
    struct Property {
        uint32 parent;
        PropertyClass class;
        uint8 x;
        uint8 y;
        uint8 z;
        uint8 dx;
        uint8 dz;
    }

    /*** STORAGE ***/

    /// @dev Ensures that property occupies unique part of the universe.
    bool[100][100][100] public world;

    /// @dev An array containing the Property struct for all properties in existence. The ID
    ///  of each property is actually an index into this array.
    Property[] properties;

    /// @dev An array containing the district addresses in existence.
    uint256[] districts;

    /// @dev A measure of world progression.
    uint256 public progress;

    /// @dev The fee associated with constructing a unit property.
    uint256 public unitCreationFee = 0.05 ether;

    /// @dev Keeps track whether updating data is paused.
    bool public updateEnabled = true;

    /// @dev A mapping from property IDs to the address that owns them. All properties have
    ///  some valid owner address, even gen0 properties are created with a non-zero owner.
    mapping (uint256 => address) public propertyIndexToOwner;

    /// @dev A mapping from property IDs to the data that is stored on them.
    mapping (uint256 => string) public propertyIndexToData;

    /// @dev A mapping from owner address to count of tokens that address owns.
    ///  Used internally inside balanceOf() to resolve ownership count.
    mapping (address => uint256) ownershipTokenCount;

    /// @dev Mappings between property nodes.
    mapping (uint256 => uint256) public districtToBuildingsCount;
    mapping (uint256 => uint256[]) public districtToBuildings;
    mapping (uint256 => uint256) public buildingToUnitCount;
    mapping (uint256 => uint256[]) public buildingToUnits;

    /// @dev A mapping from building propertyId to unit construction privacy.
    mapping (uint256 => bool) public buildingIsPublic;

    /// @dev A mapping from PropertyIDs to an address that has been approved to call
    ///  transferFrom(). Each Property can only have one approved address for transfer
    ///  at any time. A zero value means no approval is outstanding.
    mapping (uint256 => address) public propertyIndexToApproved;

    /// @dev Assigns ownership of a specific Property to an address.
    function _transfer(address _from, address _to, uint256 _tokenId) internal {
      // since the number of properties is capped to 2^32
      // there is no way to overflow this
      ownershipTokenCount[_to]++;
      // transfer ownership
      propertyIndexToOwner[_tokenId] = _to;
      // When creating new properties _from is 0x0, but we can't account that address.
      if (_from != address(0)) {
          ownershipTokenCount[_from]--;
          // clear any previously approved ownership exchange
          delete propertyIndexToApproved[_tokenId];
      }
      // Emit the transfer event.
      Transfer(_from, _to, _tokenId);
    }

    function _createUnit(
      uint256 _parent,
      uint256 _x,
      uint256 _y,
      uint256 _z,
      address _owner
    )
        internal
        returns (uint)
    {
      require(_x == uint256(uint8(_x)));
      require(_y == uint256(uint8(_y)));
      require(_z == uint256(uint8(_z)));
      require(!world[_x][_y][_z]);
      world[_x][_y][_z] = true;
      return _createProperty(
        _parent,
        PropertyClass.UNIT,
        _x,
        _y,
        _z,
        0,
        0,
        _owner
      );
    }

    function _createBuilding(
      uint256 _parent,
      uint256 _x,
      uint256 _y,
      uint256 _z,
      uint256 _dx,
      uint256 _dz,
      address _owner,
      bool _public
    )
        internal
        returns (uint)
    {
      require(_x == uint256(uint8(_x)));
      require(_y == uint256(uint8(_y)));
      require(_z == uint256(uint8(_z)));
      require(_dx == uint256(uint8(_dx)));
      require(_dz == uint256(uint8(_dz)));

      // Looping over world space.
      for(uint256 i = 0; i < _dx; i++) {
          for(uint256 j = 0; j <_dz; j++) {
              if (world[_x + i][0][_z + j]) {
                  revert();
              }
              world[_x + i][0][_z + j] = true;
          }
      }

      uint propertyId = _createProperty(
        _parent,
        PropertyClass.BUILDING,
        _x,
        _y,
        _z,
        _dx,
        _dz,
        _owner
      );

      districtToBuildingsCount[_parent]++;
      districtToBuildings[_parent].push(propertyId);
      buildingIsPublic[propertyId] = _public;
      return propertyId;
    }

    function _createDistrict(
      uint256 _x,
      uint256 _z,
      uint256 _dx,
      uint256 _dz
    )
        internal
        returns (uint)
    {
      require(_x == uint256(uint8(_x)));
      require(_z == uint256(uint8(_z)));
      require(_dx == uint256(uint8(_dx)));
      require(_dz == uint256(uint8(_dz)));

      uint propertyId = _createProperty(
        districts.length,
        PropertyClass.DISTRICT,
        _x,
        0,
        _z,
        _dx,
        _dz,
        cooAddress
      );

      districts.push(propertyId);
      return propertyId;

    }


    /// @dev An internal method that creates a new property and stores it. This
    ///  method doesn't do any checking and should only be called when the
    ///  input data is known to be valid. Will generate both a Construct event
    ///  and a Transfer event.
    function _createProperty(
        uint256 _parent,
        PropertyClass _class,
        uint256 _x,
        uint256 _y,
        uint256 _z,
        uint256 _dx,
        uint256 _dz,
        address _owner
    )
        internal
        returns (uint)
    {
        require(_x == uint256(uint8(_x)));
        require(_y == uint256(uint8(_y)));
        require(_z == uint256(uint8(_z)));
        require(_dx == uint256(uint8(_dx)));
        require(_dz == uint256(uint8(_dz)));
        require(_parent == uint256(uint32(_parent)));
        require(uint256(_class) <= 3);

        Property memory _property = Property({
            parent: uint32(_parent),
            class: _class,
            x: uint8(_x),
            y: uint8(_y),
            z: uint8(_z),
            dx: uint8(_dx),
            dz: uint8(_dz)
        });
        uint256 _tokenId = properties.push(_property) - 1;

        // It's never going to happen, 4 billion properties is A LOT, but
        // let's just be 100% sure we never let this happen.
        require(_tokenId <= 4294967295);

        Construct(
            _owner,
            _tokenId,
            _property.class,
            _property.x,
            _property.y,
            _property.z,
            _property.dx,
            _property.dz,
            ""
        );

        // This will assign ownership, and also emit the Transfer event as
        // per ERC721 draft
        _transfer(0, _owner, _tokenId);

        return _tokenId;
    }

    /// @dev Computing height of a building with respect to city progression.
    function _computeHeight(
      uint256 _x,
      uint256 _z,
      uint256 _height
    ) internal view returns (uint256) {
        uint256 x = _x < 50 ? 50 - _x : _x - 50;
        uint256 z = _z < 50 ? 50 - _z : _z - 50;
        uint256 distance = x > z ? x : z;
        if (distance > progress) {
          return 1;
        }
        uint256 scale = 100 - (distance * 100) / progress ;
        uint256 height = 2 * progress * _height * scale / 10000;
        return height > 0 ? height : 1;
    }

    /// @dev Convenience function to see if this building has room for a unit.
    function canCreateUnit(uint256 _buildingId)
        public
        view
        returns(bool)
    {
      Property storage _property = properties[_buildingId];
      if (_property.class == PropertyClass.BUILDING &&
            (buildingIsPublic[_buildingId] ||
              propertyIndexToOwner[_buildingId] == msg.sender)
      ) {
        uint256 totalVolume = _property.dx * _property.dz *
          (_computeHeight(_property.x, _property.z, _property.y) - 1);
        uint256 totalUnits = buildingToUnitCount[_buildingId];
        return totalUnits < totalVolume;
      }
      return false;
    }

    /// @dev This internal function skips all validation checks. Ensure that
    //   canCreateUnit() is required before calling this method.
    function _createUnitHelper(uint256 _buildingId, address _owner)
        internal
        returns(uint256)
    {
        // Grab a reference to the property in storage.
        Property storage _property = properties[_buildingId];
        uint256 totalArea = _property.dx * _property.dz;
        uint256 index = buildingToUnitCount[_buildingId];

        // Calculate next location.
        uint256 y = index / totalArea + 1;
        uint256 intermediate = index % totalArea;
        uint256 z = intermediate / _property.dx;
        uint256 x = intermediate % _property.dx;

        uint256 unitId = _createUnit(
          _buildingId,
          x + _property.x,
          y,
          z + _property.z,
          _owner
        );

        buildingToUnitCount[_buildingId]++;
        buildingToUnits[_buildingId].push(unitId);

        // Return the new unit's ID.
        return unitId;
    }

    /// @dev Update allows for setting a building privacy.
    function updateBuildingPrivacy(uint _tokenId, bool _public) public {
        require(propertyIndexToOwner[_tokenId] == msg.sender);
        buildingIsPublic[_tokenId] = _public;
    }

    /// @dev Update allows for setting the data associated to a property.
    function updatePropertyData(uint _tokenId, string _data) public {
        require(updateEnabled);
        address _owner = propertyIndexToOwner[_tokenId];
        require(msg.sender == _owner);
        propertyIndexToData[_tokenId] = _data;
        Property memory _property = properties[_tokenId];
        Construct(
            _owner,
            _tokenId,
            _property.class,
            _property.x,
            _property.y,
            _property.z,
            _property.dx,
            _property.dz,
            _data
        );
    }
}

// File: contracts-origin/ERC721Draft.sol

/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
    function implementsERC721() public pure returns (bool);
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) public view returns (address owner);
    function approve(address _to, uint256 _tokenId) public;
    function transferFrom(address _from, address _to, uint256 _tokenId) public;
    function transfer(address _to, uint256 _tokenId) public;
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    // Optional
    // function name() public view returns (string name);
    // function symbol() public view returns (string symbol);
    // function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
    // function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}

// File: contracts-origin/AetherOwnership.sol

/// @title The facet of the Aether core contract that manages ownership, ERC-721 (draft) compliant.
/// @dev Ref: https://github.com/ethereum/EIPs/issues/721
///  See the PropertyCore contract documentation to understand how the various contract facets are arranged.
contract AetherOwnership is AetherBase, ERC721 {

    /// @notice Name and symbol of the non fungible token, as defined in ERC721.
    string public name = "Aether";
    string public symbol = "AETH";

    function implementsERC721() public pure returns (bool)
    {
        return true;
    }

    // Internal utility functions: These functions all assume that their input arguments
    // are valid. We leave it to public methods to sanitize their inputs and follow
    // the required logic.

    /// @dev Checks if a given address is the current owner of a particular Property.
    /// @param _claimant the address we are validating against.
    /// @param _tokenId property id, only valid when > 0
    function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
        return propertyIndexToOwner[_tokenId] == _claimant;
    }

    /// @dev Checks if a given address currently has transferApproval for a particular Property.
    /// @param _claimant the address we are confirming property is approved for.
    /// @param _tokenId property id, only valid when > 0
    function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
        return propertyIndexToApproved[_tokenId] == _claimant;
    }

    /// @dev Marks an address as being approved for transferFrom(), overwriting any previous
    ///  approval. Setting _approved to address(0) clears all transfer approval.
    ///  NOTE: _approve() does NOT send the Approval event. This is intentional because
    ///  _approve() and transferFrom() are used together for putting Properties on auction, and
    ///  there is no value in spamming the log with Approval events in that case.
    function _approve(uint256 _tokenId, address _approved) internal {
        propertyIndexToApproved[_tokenId] = _approved;
    }

    /// @dev Transfers a property owned by this contract to the specified address.
    ///  Used to rescue lost properties. (There is no "proper" flow where this contract
    ///  should be the owner of any Property. This function exists for us to reassign
    ///  the ownership of Properties that users may have accidentally sent to our address.)
    /// @param _propertyId - ID of property
    /// @param _recipient - Address to send the property to
    function rescueLostProperty(uint256 _propertyId, address _recipient) public onlyCOO whenNotPaused {
        require(_owns(this, _propertyId));
        _transfer(this, _recipient, _propertyId);
    }

    /// @notice Returns the number of Properties owned by a specific address.
    /// @param _owner The owner address to check.
    /// @dev Required for ERC-721 compliance
    function balanceOf(address _owner) public view returns (uint256 count) {
        return ownershipTokenCount[_owner];
    }

    /// @notice Transfers a Property to another address. If transferring to a smart
    ///  contract be VERY CAREFUL to ensure that it is aware of ERC-721 (or
    ///  Laputa specifically) or your Property may be lost forever. Seriously.
    /// @param _to The address of the recipient, can be a user or contract.
    /// @param _tokenId The ID of the Property to transfer.
    /// @dev Required for ERC-721 compliance.
    function transfer(
        address _to,
        uint256 _tokenId
    )
        public
        whenNotPaused
    {
        // Safety check to prevent against an unexpected 0x0 default.
        require(_to != address(0));
        // You can only send your own property.
        require(_owns(msg.sender, _tokenId));

        // Reassign ownership, clear pending approvals, emit Transfer event.
        _transfer(msg.sender, _to, _tokenId);
    }

    /// @notice Grant another address the right to transfer a specific Property via
    ///  transferFrom(). This is the preferred flow for transfering NFTs to contracts.
    /// @param _to The address to be granted transfer approval. Pass address(0) to
    ///  clear all approvals.
    /// @param _tokenId The ID of the Property that can be transferred if this call succeeds.
    /// @dev Required for ERC-721 compliance.
    function approve(
        address _to,
        uint256 _tokenId
    )
        public
        whenNotPaused
    {
        // Only an owner can grant transfer approval.
        require(_owns(msg.sender, _tokenId));

        // Register the approval (replacing any previous approval).
        _approve(_tokenId, _to);

        // Emit approval event.
        Approval(msg.sender, _to, _tokenId);
    }

    /// @notice Transfer a Property owned by another address, for which the calling address
    ///  has previously been granted transfer approval by the owner.
    /// @param _from The address that owns the Property to be transfered.
    /// @param _to The address that should take ownership of the Property. Can be any address,
    ///  including the caller.
    /// @param _tokenId The ID of the Property to be transferred.
    /// @dev Required for ERC-721 compliance.
    function transferFrom(
        address _from,
        address _to,
        uint256 _tokenId
    )
        public
        whenNotPaused
    {
        // Check for approval and valid ownership
        require(_approvedFor(msg.sender, _tokenId));
        require(_owns(_from, _tokenId));

        // Reassign ownership (also clears pending approvals and emits Transfer event).
        _transfer(_from, _to, _tokenId);
    }

    /// @notice Returns the total number of Properties currently in existence.
    /// @dev Required for ERC-721 compliance.
    function totalSupply() public view returns (uint) {
        return properties.length;
    }

    function totalDistrictSupply() public view returns(uint count) {
        return districts.length;
    }

    /// @notice Returns the address currently assigned ownership of a given Property.
    /// @dev Required for ERC-721 compliance.
    function ownerOf(uint256 _tokenId)
        public
        view
        returns (address owner)
    {
        owner = propertyIndexToOwner[_tokenId];

        require(owner != address(0));
    }


    /// @notice Returns a list of all Property IDs assigned to an address.
    /// @param _owner The owner whose Properties we are interested in.
    /// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
    ///  expensive (it walks the entire Kitty array looking for cats belonging to owner),
    ///  but it also returns a dynamic array, which is only supported for web3 calls, and
    ///  not contract-to-contract calls.
    function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
        uint256 tokenCount = balanceOf(_owner);

        if (tokenCount == 0) {
            // Return an empty array
            return new uint256[](0);
        } else {
            uint256[] memory result = new uint256[](tokenCount);
            uint256 totalProperties = totalSupply();
            uint256 resultIndex = 0;

            // We count on the fact that all properties have IDs starting at 1 and increasing
            // sequentially up to the totalProperties count.
            uint256 tokenId;

            for (tokenId = 1; tokenId <= totalProperties; tokenId++) {
                if (propertyIndexToOwner[tokenId] == _owner) {
                    result[resultIndex] = tokenId;
                    resultIndex++;
                }
            }

            return result;
        }
    }
}

// File: contracts-origin/Auction/ClockAuctionBase.sol

/// @title Auction Core
/// @dev Contains models, variables, and internal methods for the auction.
contract ClockAuctionBase {

    // Represents an auction on an NFT
    struct Auction {
        // Current owner of NFT
        address seller;
        // Price (in wei) at beginning of auction
        uint128 startingPrice;
        // Price (in wei) at end of auction
        uint128 endingPrice;
        // Duration (in seconds) of auction
        uint64 duration;
        // Time when auction started
        // NOTE: 0 if this auction has been concluded
        uint64 startedAt;
    }

    // Reference to contract tracking NFT ownership
    ERC721 public nonFungibleContract;

    // Cut owner takes on each auction, measured in basis points (1/100 of a percent).
    // Values 0-10,000 map to 0%-100%
    uint256 public ownerCut;

    // Map from token ID to their corresponding auction.
    mapping (uint256 => Auction) tokenIdToAuction;

    event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration);
    event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address winner);
    event AuctionCancelled(uint256 tokenId);

    /// @dev DON'T give me your money.
    function() external {}

    // Modifiers to check that inputs can be safely stored with a certain
    // number of bits. We use constants and multiple modifiers to save gas.
    modifier canBeStoredWith64Bits(uint256 _value) {
        require(_value <= 18446744073709551615);
        _;
    }

    modifier canBeStoredWith128Bits(uint256 _value) {
        require(_value < 340282366920938463463374607431768211455);
        _;
    }

    /// @dev Returns true if the claimant owns the token.
    /// @param _claimant - Address claiming to own the token.
    /// @param _tokenId - ID of token whose ownership to verify.
    function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
        return (nonFungibleContract.ownerOf(_tokenId) == _claimant);
    }

    /// @dev Escrows the NFT, assigning ownership to this contract.
    /// Throws if the escrow fails.
    /// @param _owner - Current owner address of token to escrow.
    /// @param _tokenId - ID of token whose approval to verify.
    function _escrow(address _owner, uint256 _tokenId) internal {
        // it will throw if transfer fails
        nonFungibleContract.transferFrom(_owner, this, _tokenId);
    }

    /// @dev Transfers an NFT owned by this contract to another address.
    /// Returns true if the transfer succeeds.
    /// @param _receiver - Address to transfer NFT to.
    /// @param _tokenId - ID of token to transfer.
    function _transfer(address _receiver, uint256 _tokenId) internal {
        // it will throw if transfer fails
        nonFungibleContract.transfer(_receiver, _tokenId);
    }

    /// @dev Adds an auction to the list of open auctions. Also fires the
    ///  AuctionCreated event.
    /// @param _tokenId The ID of the token to be put on auction.
    /// @param _auction Auction to add.
    function _addAuction(uint256 _tokenId, Auction _auction) internal {
        // Require that all auctions have a duration of
        // at least one minute. (Keeps our math from getting hairy!)
        require(_auction.duration >= 1 minutes);

        tokenIdToAuction[_tokenId] = _auction;

        AuctionCreated(
            uint256(_tokenId),
            uint256(_auction.startingPrice),
            uint256(_auction.endingPrice),
            uint256(_auction.duration)
        );
    }

    /// @dev Cancels an auction unconditionally.
    function _cancelAuction(uint256 _tokenId, address _seller) internal {
        _removeAuction(_tokenId);
        _transfer(_seller, _tokenId);
        AuctionCancelled(_tokenId);
    }

    /// @dev Computes the price and transfers winnings.
    /// Does NOT transfer ownership of token.
    function _bid(uint256 _tokenId, uint256 _bidAmount)
        internal
        returns (uint256)
    {
        // Get a reference to the auction struct
        Auction storage auction = tokenIdToAuction[_tokenId];

        // Explicitly check that this auction is currently live.
        // (Because of how Ethereum mappings work, we can't just count
        // on the lookup above failing. An invalid _tokenId will just
        // return an auction object that is all zeros.)
        require(_isOnAuction(auction));

        // Check that the incoming bid is higher than the current
        // price
        uint256 price = _currentPrice(auction);
        require(_bidAmount >= price);

        // Grab a reference to the seller before the auction struct
        // gets deleted.
        address seller = auction.seller;

        // The bid is good! Remove the auction before sending the fees
        // to the sender so we can't have a reentrancy attack.
        _removeAuction(_tokenId);

        // Transfer proceeds to seller (if there are any!)
        if (price > 0) {
            //  Calculate the auctioneer's cut.
            // (NOTE: _computeCut() is guaranteed to return a
            //  value <= price, so this subtraction can't go negative.)
            uint256 auctioneerCut = _computeCut(price);
            uint256 sellerProceeds = price - auctioneerCut;

            // NOTE: Doing a transfer() in the middle of a complex
            // method like this is generally discouraged because of
            // reentrancy attacks and DoS attacks if the seller is
            // a contract with an invalid fallback function. We explicitly
            // guard against reentrancy attacks by removing the auction
            // before calling transfer(), and the only thing the seller
            // can DoS is the sale of their own asset! (And if it's an
            // accident, they can call cancelAuction(). )
            seller.transfer(sellerProceeds);
        }

        // Tell the world!
        AuctionSuccessful(_tokenId, price, msg.sender);

        return price;
    }

    /// @dev Removes an auction from the list of open auctions.
    /// @param _tokenId - ID of NFT on auction.
    function _removeAuction(uint256 _tokenId) internal {
        delete tokenIdToAuction[_tokenId];
    }

    /// @dev Returns true if the NFT is on auction.
    /// @param _auction - Auction to check.
    function _isOnAuction(Auction storage _auction) internal view returns (bool) {
        return (_auction.startedAt > 0);
    }

    /// @dev Returns current price of an NFT on auction. Broken into two
    ///  functions (this one, that computes the duration from the auction
    ///  structure, and the other that does the price computation) so we
    ///  can easily test that the price computation works correctly.
    function _currentPrice(Auction storage _auction)
        internal
        view
        returns (uint256)
    {
        uint256 secondsPassed = 0;

        // A bit of insurance against negative values (or wraparound).
        // Probably not necessary (since Ethereum guarnatees that the
        // now variable doesn't ever go backwards).
        if (now > _auction.startedAt) {
            secondsPassed = now - _auction.startedAt;
        }

        return _computeCurrentPrice(
            _auction.startingPrice,
            _auction.endingPrice,
            _auction.duration,
            secondsPassed
        );
    }

    /// @dev Computes the current price of an auction. Factored out
    ///  from _currentPrice so we can run extensive unit tests.
    ///  When testing, make this function public and turn on
    ///  `Current price computation` test suite.
    function _computeCurrentPrice(
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        uint256 _secondsPassed
    )
        internal
        pure
        returns (uint256)
    {
        // NOTE: We don't use SafeMath (or similar) in this function because
        //  all of our public functions carefully cap the maximum values for
        //  time (at 64-bits) and currency (at 128-bits). _duration is
        //  also known to be non-zero (see the require() statement in
        //  _addAuction())
        if (_secondsPassed >= _duration) {
            // We've reached the end of the dynamic pricing portion
            // of the auction, just return the end price.
            return _endingPrice;
        } else {
            // Starting price can be higher than ending price (and often is!), so
            // this delta can be negative.
            int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice);

            // This multiplication can't overflow, _secondsPassed will easily fit within
            // 64-bits, and totalPriceChange will easily fit within 128-bits, their product
            // will always fit within 256-bits.
            int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration);

            // currentPriceChange can be negative, but if so, will have a magnitude
            // less that _startingPrice. Thus, this result will always end up positive.
            int256 currentPrice = int256(_startingPrice) + currentPriceChange;

            return uint256(currentPrice);
        }
    }

    /// @dev Computes owner's cut of a sale.
    /// @param _price - Sale price of NFT.
    function _computeCut(uint256 _price) internal view returns (uint256) {
        // NOTE: We don't use SafeMath (or similar) in this function because
        //  all of our entry functions carefully cap the maximum values for
        //  currency (at 128-bits), and ownerCut <= 10000 (see the require()
        //  statement in the ClockAuction constructor). The result of this
        //  function is always guaranteed to be <= _price.
        return _price * ownerCut / 10000;
    }

}

// File: zeppelin-solidity/contracts/ownership/Ownable.sol

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}

// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol

/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is Ownable {
  event Pause();
  event Unpause();

  bool public paused = false;


  /**
   * @dev modifier to allow actions only when the contract IS paused
   */
  modifier whenNotPaused() {
    require(!paused);
    _;
  }

  /**
   * @dev modifier to allow actions only when the contract IS NOT paused
   */
  modifier whenPaused {
    require(paused);
    _;
  }

  /**
   * @dev called by the owner to pause, triggers stopped state
   */
  function pause() onlyOwner whenNotPaused returns (bool) {
    paused = true;
    Pause();
    return true;
  }

  /**
   * @dev called by the owner to unpause, returns to normal state
   */
  function unpause() onlyOwner whenPaused returns (bool) {
    paused = false;
    Unpause();
    return true;
  }
}

// File: contracts-origin/Auction/ClockAuction.sol

/// @title Clock auction for non-fungible tokens.
contract ClockAuction is Pausable, ClockAuctionBase {

    /// @dev Constructor creates a reference to the NFT ownership contract
    ///  and verifies the owner cut is in the valid range.
    /// @param _nftAddress - address of a deployed contract implementing
    ///  the Nonfungible Interface.
    /// @param _cut - percent cut the owner takes on each auction, must be
    ///  between 0-10,000.
    function ClockAuction(address _nftAddress, uint256 _cut) public {
        require(_cut <= 10000);
        ownerCut = _cut;
        
        ERC721 candidateContract = ERC721(_nftAddress);
        require(candidateContract.implementsERC721());
        nonFungibleContract = candidateContract;
    }

    /// @dev Remove all Ether from the contract, which is the owner's cuts
    ///  as well as any Ether sent directly to the contract address.
    ///  Always transfers to the NFT contract, but can be called either by
    ///  the owner or the NFT contract.
    function withdrawBalance() external {
        address nftAddress = address(nonFungibleContract);

        require(
            msg.sender == owner ||
            msg.sender == nftAddress
        );
        nftAddress.transfer(this.balance);
    }

    /// @dev Creates and begins a new auction.
    /// @param _tokenId - ID of token to auction, sender must be owner.
    /// @param _startingPrice - Price of item (in wei) at beginning of auction.
    /// @param _endingPrice - Price of item (in wei) at end of auction.
    /// @param _duration - Length of time to move between starting
    ///  price and ending price (in seconds).
    /// @param _seller - Seller, if not the message sender
    function createAuction(
        uint256 _tokenId,
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        address _seller
    )
        public
        whenNotPaused
        canBeStoredWith128Bits(_startingPrice)
        canBeStoredWith128Bits(_endingPrice)
        canBeStoredWith64Bits(_duration)
    {
        require(_owns(msg.sender, _tokenId));
        _escrow(msg.sender, _tokenId);
        Auction memory auction = Auction(
            _seller,
            uint128(_startingPrice),
            uint128(_endingPrice),
            uint64(_duration),
            uint64(now)
        );
        _addAuction(_tokenId, auction);
    }

    /// @dev Bids on an open auction, completing the auction and transferring
    ///  ownership of the NFT if enough Ether is supplied.
    /// @param _tokenId - ID of token to bid on.
    function bid(uint256 _tokenId)
        public
        payable
        whenNotPaused
    {
        // _bid will throw if the bid or funds transfer fails
        _bid(_tokenId, msg.value);
        _transfer(msg.sender, _tokenId);
    }

    /// @dev Cancels an auction that hasn't been won yet.
    ///  Returns the NFT to original owner.
    /// @notice This is a state-modifying function that can
    ///  be called while the contract is paused.
    /// @param _tokenId - ID of token on auction
    function cancelAuction(uint256 _tokenId)
        public
    {
        Auction storage auction = tokenIdToAuction[_tokenId];
        require(_isOnAuction(auction));
        address seller = auction.seller;
        require(msg.sender == seller);
        _cancelAuction(_tokenId, seller);
    }

    /// @dev Cancels an auction when the contract is paused.
    ///  Only the owner may do this, and NFTs are returned to
    ///  the seller. This should only be used in emergencies.
    /// @param _tokenId - ID of the NFT on auction to cancel.
    function cancelAuctionWhenPaused(uint256 _tokenId)
        whenPaused
        onlyOwner
        public
    {
        Auction storage auction = tokenIdToAuction[_tokenId];
        require(_isOnAuction(auction));
        _cancelAuction(_tokenId, auction.seller);
    }

    /// @dev Returns auction info for an NFT on auction.
    /// @param _tokenId - ID of NFT on auction.
    function getAuction(uint256 _tokenId)
        public
        view
        returns
    (
        address seller,
        uint256 startingPrice,
        uint256 endingPrice,
        uint256 duration,
        uint256 startedAt
    ) {
        Auction storage auction = tokenIdToAuction[_tokenId];
        require(_isOnAuction(auction));
        return (
            auction.seller,
            auction.startingPrice,
            auction.endingPrice,
            auction.duration,
            auction.startedAt
        );
    }

    /// @dev Returns the current price of an auction.
    /// @param _tokenId - ID of the token price we are checking.
    function getCurrentPrice(uint256 _tokenId)
        public
        view
        returns (uint256)
    {
        Auction storage auction = tokenIdToAuction[_tokenId];
        require(_isOnAuction(auction));
        return _currentPrice(auction);
    }

}

// File: contracts-origin/Auction/AetherClockAuction.sol

/// @title Clock auction modified for sale of property
contract AetherClockAuction is ClockAuction {

    // @dev Sanity check that allows us to ensure that we are pointing to the
    //  right auction in our setSaleAuctionAddress() call.
    bool public isAetherClockAuction = true;

    // Tracks last 5 sale price of gen0 property sales
    uint256 public saleCount;
    uint256[5] public lastSalePrices;

    // Delegate constructor
    function AetherClockAuction(address _nftAddr, uint256 _cut) public
      ClockAuction(_nftAddr, _cut) {}


    /// @dev Creates and begins a new auction.
    /// @param _tokenId - ID of token to auction, sender must be owner.
    /// @param _startingPrice - Price of item (in wei) at beginning of auction.
    /// @param _endingPrice - Price of item (in wei) at end of auction.
    /// @param _duration - Length of auction (in seconds).
    /// @param _seller - Seller, if not the message sender
    function createAuction(
        uint256 _tokenId,
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        address _seller
    )
        public
        canBeStoredWith128Bits(_startingPrice)
        canBeStoredWith128Bits(_endingPrice)
        canBeStoredWith64Bits(_duration)
    {
        require(msg.sender == address(nonFungibleContract));
        _escrow(_seller, _tokenId);
        Auction memory auction = Auction(
            _seller,
            uint128(_startingPrice),
            uint128(_endingPrice),
            uint64(_duration),
            uint64(now)
        );
        _addAuction(_tokenId, auction);
    }

    /// @dev Updates lastSalePrice if seller is the nft contract
    /// Otherwise, works the same as default bid method.
    function bid(uint256 _tokenId)
        public
        payable
    {
        // _bid verifies token ID size
        address seller = tokenIdToAuction[_tokenId].seller;
        uint256 price = _bid(_tokenId, msg.value);
        _transfer(msg.sender, _tokenId);

        // If not a gen0 auction, exit
        if (seller == address(nonFungibleContract)) {
            // Track gen0 sale prices
            lastSalePrices[saleCount % 5] = price;
            saleCount++;
        }
    }

    function averageSalePrice() public view returns (uint256) {
        uint256 sum = 0;
        for (uint256 i = 0; i < 5; i++) {
            sum += lastSalePrices[i];
        }
        return sum / 5;
    }
}

// File: contracts-origin/AetherAuction.sol

/// @title Handles creating auctions for sale and siring of properties.
///  This wrapper of ReverseAuction exists only so that users can create
///  auctions with only one transaction.
contract AetherAuction is AetherOwnership{

    /// @dev The address of the ClockAuction contract that handles sales of Aether. This
    ///  same contract handles both peer-to-peer sales as well as the gen0 sales which are
    ///  initiated every 15 minutes.
    AetherClockAuction public saleAuction;

    /// @dev Sets the reference to the sale auction.
    /// @param _address - Address of sale contract.
    function setSaleAuctionAddress(address _address) public onlyCEO {
        AetherClockAuction candidateContract = AetherClockAuction(_address);

        // NOTE: verify that a contract is what we expect
        require(candidateContract.isAetherClockAuction());

        // Set the new contract address
        saleAuction = candidateContract;
    }

    /// @dev Put a property up for auction.
    ///  Does some ownership trickery to create auctions in one tx.
    function createSaleAuction(
        uint256 _propertyId,
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration
    )
        public
        whenNotPaused
    {
        // Auction contract checks input sizes
        // If property is already on any auction, this will throw
        // because it will be owned by the auction contract.
        require(_owns(msg.sender, _propertyId));
        _approve(_propertyId, saleAuction);
        // Sale auction throws if inputs are invalid and clears
        // transfer and sire approval after escrowing the property.
        saleAuction.createAuction(
            _propertyId,
            _startingPrice,
            _endingPrice,
            _duration,
            msg.sender
        );
    }

    /// @dev Transfers the balance of the sale auction contract
    /// to the AetherCore contract. We use two-step withdrawal to
    /// prevent two transfer calls in the auction bid function.
    function withdrawAuctionBalances() external onlyCOO {
        saleAuction.withdrawBalance();
    }
}

// File: contracts-origin/AetherConstruct.sol

// Auction wrapper functions


/// @title all functions related to creating property
contract AetherConstruct is AetherAuction {

    uint256 public districtLimit = 16;
    uint256 public startingPrice = 1 ether;
    uint256 public auctionDuration = 1 days;

    /// @dev Units can be contructed within public and owned buildings.
    function createUnit(uint256 _buildingId)
        public
        payable
        returns(uint256)
    {
        require(canCreateUnit(_buildingId));
        require(msg.value >= unitCreationFee);
        if (msg.value > unitCreationFee)
            msg.sender.transfer(msg.value - unitCreationFee);
        uint256 propertyId = _createUnitHelper(_buildingId, msg.sender);
        return propertyId;
    }

    /// @dev Creation of unit properties. Only callable by COO
    function createUnitOmni(
      uint32 _buildingId,
      address _owner
    )
      public
      onlyCOO
    {
        if (_owner == address(0)) {
             _owner = cooAddress;
        }
        require(canCreateUnit(_buildingId));
        _createUnitHelper(_buildingId, _owner);
    }

    /// @dev Creation of building properties. Only callable by COO
    function createBuildingOmni(
      uint32 _districtId,
      uint8 _x,
      uint8 _y,
      uint8 _z,
      uint8 _dx,
      uint8 _dz,
      address _owner,
      bool _open
    )
      public
      onlyCOO
    {
        if (_owner == address(0)) {
             _owner = cooAddress;
        }
        _createBuilding(_districtId, _x, _y, _z, _dx, _dz, _owner, _open);
    }

    /// @dev Creation of district properties, up to a limit. Only callable by COO
    function createDistrictOmni(
      uint8 _x,
      uint8 _z,
      uint8 _dx,
      uint8 _dz
    )
      public
      onlyCOO
    {
      require(districts.length < districtLimit);
      _createDistrict(_x, _z, _dx, _dz);
    }


    /// @dev Creates a new property with the given details and
    ///  creates an auction for it. Only callable by COO.
    function createBuildingAuction(
      uint32 _districtId,
      uint8 _x,
      uint8 _y,
      uint8 _z,
      uint8 _dx,
      uint8 _dz,
      bool _open
    ) public onlyCOO {
        uint256 propertyId = _createBuilding(_districtId, _x, _y, _z, _dx, _dz, address(this), _open);
        _approve(propertyId, saleAuction);

        saleAuction.createAuction(
            propertyId,
            _computeNextPrice(),
            0,
            auctionDuration,
            address(this)
        );
    }

    /// @dev Updates the minimum payment required for calling createUnit(). Can only
    ///  be called by the COO address.
    function setUnitCreationFee(uint256 _value) public onlyCOO {
        unitCreationFee = _value;
    }

    /// @dev Update world progression factor allowing for buildings to grow taller
    //   as the city expands. Only callable by COO.
    function setProgress(uint256 _progress) public onlyCOO {
        require(_progress <= 100);
        require(_progress > progress);
        progress = _progress;
    }

    /// @dev Set property data updates flag. Only callable by COO.
    function setUpdateState(bool _updateEnabled) public onlyCOO {
        updateEnabled = _updateEnabled;
    }

    /// @dev Computes the next auction starting price, given the average of the past
    ///  5 prices + 50%.
    function _computeNextPrice() internal view returns (uint256) {
        uint256 avePrice = saleAuction.averageSalePrice();

        // sanity check to ensure we don't overflow arithmetic (this big number is 2^128-1).
        require(avePrice < 340282366920938463463374607431768211455);

        uint256 nextPrice = avePrice + (avePrice / 2);

        // We never auction for less than starting price
        if (nextPrice < startingPrice) {
            nextPrice = startingPrice;
        }

        return nextPrice;
    }
}

// File: contracts-origin/AetherCore.sol

/// @title Aether: A city on the Ethereum blockchain.
/// @author Axiom Zen (https://www.axiomzen.co)
contract AetherCore is AetherConstruct {

    // This is the main Aether contract. In order to keep our code seperated into logical sections,
    // we've broken it up in two ways.  The auctions are seperate since their logic is somewhat complex
    // and there's always a risk of subtle bugs. By keeping them in their own contracts, we can upgrade
    // them without disrupting the main contract that tracks property ownership.
    //
    // Secondly, we break the core contract into multiple files using inheritence, one for each major
    // facet of functionality of Aether. This allows us to keep related code bundled together while still
    // avoiding a single giant file with everything in it. The breakdown is as follows:
    //
    //      - AetherBase: This is where we define the most fundamental code shared throughout the core
    //             functionality. This includes our main data storage, constants and data types, plus
    //             internal functions for managing these items.
    //
    //      - AetherAccessControl: This contract manages the various addresses and constraints for operations
    //             that can be executed only by specific roles. Namely CEO, CFO and COO.
    //
    //      - AetherOwnership: This provides the methods required for basic non-fungible token
    //             transactions, following the draft ERC-721 spec (https://github.com/ethereum/EIPs/issues/721).
    //
    //      - AetherAuction: Here we have the public methods for auctioning or bidding on property.
    //             The actual auction functionality is handled in two sibling contracts while auction
    //             creation and bidding is mostly mediated through this facet of the core contract.
    //
    //      - AetherConstruct: This final facet contains the functionality we use for creating new gen0 cats.

    //             the community is new).

    // Set in case the core contract is broken and an upgrade is required
    address public newContractAddress;

    /// @notice Creates the main Aether smart contract instance.
    function AetherCore() public {
        // Starts paused.
        paused = true;

        // the creator of the contract is the initial CEO
        ceoAddress = msg.sender;

        // the creator of the contract is also the initial COO
        cooAddress = msg.sender;
    }

    /// @dev Used to mark the smart contract as upgraded, in case there is a serious
    ///  breaking bug. This method does nothing but keep track of the new contract and
    ///  emit a message indicating that the new address is set. It's up to clients of this
    ///  contract to update to the new contract address in that case. (This contract will
    ///  be paused indefinitely if such an upgrade takes place.)
    /// @param _v2Address new address
    function setNewAddress(address _v2Address) public onlyCEO whenPaused {
        // See README.md for updgrade plan
        newContractAddress = _v2Address;
        ContractUpgrade(_v2Address);
    }

    /// @notice No tipping!
    /// @dev Reject all Ether from being sent here, unless it's from one of the
    ///  two auction contracts. (Hopefully, we can prevent user accidents.)
    function() external payable {
        require(
            msg.sender == address(saleAuction)
        );
    }

    /// @notice Returns all the relevant information about a specific property.
    /// @param _id The ID of the property of interest.
    function getProperty(uint256 _id)
        public
        view
        returns (
        uint32 parent,
        uint8 class,
        uint8 x,
        uint8 y,
        uint8 z,
        uint8 dx,
        uint8 dz,
        uint8 height
    ) {
        Property storage property = properties[_id];
        parent = uint32(property.parent);
        class = uint8(property.class);

        height = uint8(property.y);
        if (property.class == PropertyClass.BUILDING) {
          y = uint8(_computeHeight(property.x, property.z, property.y));
        } else {
          y = uint8(property.y);
        }

        x = uint8(property.x);
        z = uint8(property.z);
        dx = uint8(property.dx);
        dz = uint8(property.dz);
    }

    /// @dev Override unpause so it requires all external contract addresses
    ///  to be set before contract can be unpaused. Also, we can't have
    ///  newContractAddress set either, because then the contract was upgraded.
    function unpause() public onlyCEO whenPaused {
        require(saleAuction != address(0));
        require(newContractAddress == address(0));
        // Actually unpause the contract.
        super.unpause();
    }
}

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[],"name":"cfoAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"approve","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"ceoAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"auctionDuration","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"implementsERC721","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":false,"inputs":[{"name":"_tokenId","type":"uint256"},{"name":"_public","type":"bool"}],"name":"updateBuildingPrivacy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"buildingToUnitCount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_updateEnabled","type":"bool"}],"name":"setUpdateState","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_newCEO","type":"address"}],"name":"setCEO","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_x","type":"uint8"},{"name":"_z","type":"uint8"},{"name":"_dx","type":"uint8"},{"name":"_dz","type":"uint8"}],"name":"createDistrictOmni","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_districtId","type":"uint32"},{"name":"_x","type":"uint8"},{"name":"_y","type":"uint8"},{"name":"_z","type":"uint8"},{"name":"_dx","type":"uint8"},{"name":"_dz","type":"uint8"},{"name":"_open","type":"bool"}],"name":"createBuildingAuction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_newCOO","type":"address"}],"name":"setCOO","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_id","type":"uint256"}],"name":"getProperty","outputs":[{"name":"parent","type":"uint32"},{"name":"class","type":"uint8"},{"name":"x","type":"uint8"},{"name":"y","type":"uint8"},{"name":"z","type":"uint8"},{"name":"dx","type":"uint8"},{"name":"dz","type":"uint8"},{"name":"height","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_propertyId","type":"uint256"},{"name":"_startingPrice","type":"uint256"},{"name":"_endingPrice","type":"uint256"},{"name":"_duration","type":"uint256"}],"name":"createSaleAuction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"updateEnabled","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newCFO","type":"address"}],"name":"setCFO","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"districtToBuildingsCount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_tokenId","type":"uint256"},{"name":"_data","type":"string"}],"name":"updatePropertyData","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"progress","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"name":"buildingToUnits","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdrawBalance","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"name":"owner","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"propertyIndexToApproved","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"newContractAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_buildingId","type":"uint32"},{"name":"_owner","type":"address"}],"name":"createUnitOmni","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_address","type":"address"}],"name":"setSaleAuctionAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"count","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_v2Address","type":"address"}],"name":"setNewAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_buildingId","type":"uint256"}],"name":"createUnit","outputs":[{"name":"","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"name":"ownerTokens","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"districtLimit","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdrawAuctionBalances","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_value","type":"uint256"}],"name":"setUnitCreationFee","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"name":"districtToBuildings","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"name":"world","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"transfer","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_buildingId","type":"uint256"}],"name":"canCreateUnit","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"cooAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"propertyIndexToData","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"unitCreationFee","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"buildingIsPublic","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_propertyId","type":"uint256"},{"name":"_recipient","type":"address"}],"name":"rescueLostProperty","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"propertyIndexToOwner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_progress","type":"uint256"}],"name":"setProgress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"startingPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalDistrictSupply","outputs":[{"name":"count","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_districtId","type":"uint32"},{"name":"_x","type":"uint8"},{"name":"_y","type":"uint8"},{"name":"_z","type":"uint8"},{"name":"_dx","type":"uint8"},{"name":"_dz","type":"uint8"},{"name":"_owner","type":"address"},{"name":"_open","type":"bool"}],"name":"createBuildingOmni","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"saleAuction","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":true,"name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"approved","type":"address"},{"indexed":true,"name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":false,"name":"propertyId","type":"uint256"},{"indexed":false,"name":"class","type":"uint8"},{"indexed":false,"name":"x","type":"uint8"},{"indexed":false,"name":"y","type":"uint8"},{"indexed":false,"name":"z","type":"uint8"},{"indexed":false,"name":"dx","type":"uint8"},{"indexed":false,"name":"dz","type":"uint8"},{"indexed":false,"name":"data","type":"string"}],"name":"Construct","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"newContract","type":"address"}],"name":"ContractUpgrade","type":"event"}]

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

Swarm Source

bzzr://915f094bd33721ea50df1895ad20a891377cb5b76da4cbb39f2ec348486f80d9
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.