English
USD
Popular
Other
AgentMile
AgentMile
ICO
AgentMile is the decentralized commercial real estate leasing platform powered by AI.
Category: Platform, Artificial intelligence, Blockchain
Founded: Jul 2, 2018
Country: Estonia
Sadly, you’ve exceeded the limit of adding to favorite.
The limit possible is 5
Increase the limit
Go to website MVP is ready
Registered on Neironix

Information about ICO

Platform Ethereum
Accepted ETH, BTC
Start date Sep 15, 2018
End date Oct 15, 2018
Token price 1 ESTATE =
Released tokens 100 000 000
Soft cap
Hard cap
Raised
Minimal amount 1 ESTATE
Token ESTATE - 0.2000000000$
Periods
15.09.2018 15.10.2018
100.00%
AgentMile ESTATE Token (ESTATE)
AgentMile ESTATE Token (ESTATE)
Token
Ethereum
Utility
ERC-20
Platform: Ethereum
trade -
AgentMile - token distribution
AgentMile - use of funds
Smart contract - AgentMile
pragma solidity ^0.4.20;

contract Token {
  
  function totalSupply () public view returns (uint256 supply);
  
  function balanceOf (address _owner) public view returns (uint256 balance);

  function transfer (address _to, uint256 _value)
  public returns (bool success);

  function transferFrom (address _from, address _to, uint256 _value)
  public returns (bool success);

  function approve (address _spender, uint256 _value)
  public returns (bool success);

  function allowance (address _owner, address _spender)
  public view returns (uint256 remaining);

  event Transfer (address indexed _from, address indexed _to, uint256 _value);

  event Approval (
    address indexed _owner, address indexed _spender, uint256 _value);
}

pragma solidity ^0.4.20;

contract SafeMath {
  uint256 constant private MAX_UINT256 =
    0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

  function safeAdd (uint256 x, uint256 y)
  pure internal
  returns (uint256 z) {
    assert (x <= MAX_UINT256 - y);
    return x + y;
  }

  function safeSub (uint256 x, uint256 y)
  pure internal
  returns (uint256 z) {
    assert (x >= y);
    return x - y;
  }

  function safeMul (uint256 x, uint256 y)
  pure internal
  returns (uint256 z) {
    if (y == 0) return 0; // Prevent division by zero at the next line
    assert (x <= MAX_UINT256 / y);
    return x * y;
  }
}

contract AbstractToken is Token, SafeMath {
  function AbstractToken () public {
    // Do nothing
  }

  function balanceOf (address _owner) public view returns (uint256 balance) {
    return accounts [_owner];
  }

  function transfer (address _to, uint256 _value)
  public returns (bool success) {
    uint256 fromBalance = accounts [msg.sender];
    if (fromBalance < _value) return false;
    if (_value > 0 && msg.sender != _to) {
      accounts [msg.sender] = safeSub (fromBalance, _value);
      accounts [_to] = safeAdd (accounts [_to], _value);
    }
    Transfer (msg.sender, _to, _value);
    return true;
  }

  function transferFrom (address _from, address _to, uint256 _value)
  public returns (bool success) {
    uint256 spenderAllowance = allowances [_from][msg.sender];
    if (spenderAllowance < _value) return false;
    uint256 fromBalance = accounts [_from];
    if (fromBalance < _value) return false;

    allowances [_from][msg.sender] =
      safeSub (spenderAllowance, _value);

    if (_value > 0 && _from != _to) {
      accounts [_from] = safeSub (fromBalance, _value);
      accounts [_to] = safeAdd (accounts [_to], _value);
    }
    Transfer (_from, _to, _value);
    return true;
  }

  function approve (address _spender, uint256 _value)
  public returns (bool success) {
    allowances [msg.sender][_spender] = _value;
    Approval (msg.sender, _spender, _value);

    return true;
  }

  function allowance (address _owner, address _spender)
  public view returns (uint256 remaining) {
    return allowances [_owner][_spender];
  }

  mapping (address => uint256) internal accounts;

  mapping (address => mapping (address => uint256)) internal allowances;
}

contract EstateToken is AbstractToken {
  address private owner;
  uint256 tokenCount;
  bool frozen = false;

  function EstateToken (uint256 _tokenCount) public {
    owner = msg.sender;
    tokenCount = _tokenCount;
    accounts [msg.sender] = _tokenCount;
  }

  function totalSupply () public view returns (uint256 supply) {
    return tokenCount;
  }

  function name () public pure returns (string result) {
    return "AgentMile Estate Tokens";
  }

  function symbol () public pure returns (string result) {
    return "ESTATE";
  }

  function decimals () public pure returns (uint8 result) {
    return 8;
  }

  function transfer (address _to, uint256 _value)
    public returns (bool success) {
    if (frozen) return false;
    else return AbstractToken.transfer (_to, _value);
  }

  function transferFrom (address _from, address _to, uint256 _value)
    public returns (bool success) {
    if (frozen) return false;
    else return AbstractToken.transferFrom (_from, _to, _value);
  }

  function approve (address _spender, uint256 _currentValue, uint256 _newValue)
    public returns (bool success) {
    if (allowance (msg.sender, _spender) == _currentValue)
      return approve (_spender, _newValue);
    else return false;
  }

  function burnTokens (uint256 _value) public returns (bool success) {
    if (_value > accounts [msg.sender]) return false;
    else if (_value > 0) {
      accounts [msg.sender] = safeSub (accounts [msg.sender], _value);
      tokenCount = safeSub (tokenCount, _value);

      Transfer (msg.sender, address (0), _value);
      return true;
    } else return true;
  }

  function setOwner (address _newOwner) public {
    require (msg.sender == owner);

    owner = _newOwner;
  }

  function freezeTransfers () public {
    require (msg.sender == owner);

    if (!frozen) {
      frozen = true;
      Freeze ();
    }
  }

  function unfreezeTransfers () public {
    require (msg.sender == owner);

    if (frozen) {
      frozen = false;
      Unfreeze ();
    }
  }

  event Freeze ();

  event Unfreeze ();
}
Bounty program - AgentMile - Ico - AgentMile
Platform:
Manager:
Reward:
Stack
Start date:
May 17, 2018
End date:
Dec 17, 2018
Distribution of tokens : Feb 17, 2018
Available bounties
Following
Signature BT
Review
Translate
Sharing
Bitcoin
(0.82%)
Ethereum
(1.69%)
Ripple
(-0.70%)
Bitcoin Cash
(-0.81%)
Litecoin
(5.16%)
EOS
(0.88%)
Binance Coin
(3.43%)
Stellar
(-0.85%)
Cardano
(-1.60%)
Tether
(0.00%)
Tronix
(-0.47%)
Bitcoin SV
(-4.06%)
Monero
(2.34%)
Dash
(-1.04%)
IOTA
(-1.15%)
Tezos
(-1.13%)
Ethereum Classic
(1.22%)
NEM
(-2.27%)
NEO
(-1.55%)
OKB
(3.89%)
Support Center
Tracking of cryptocurrency markets has become even more convenient with our application.
Neironix Mobile App
Download for FREE
Download App
Create account
Sign in
Contact technical support
If you have any problems with the system, please describe the problem in the form below, or send your question to: support@neironix.io