English
USD
Popular
Other
Money Rebel
Money Rebel
ICO
Site unavailable
A Marketplace of Advisors
Category: Platform, Business services, Banking
Founded: Oct 9, 2017
Country: Slovenia
Sadly, you’ve exceeded the limit of adding to favorite.
The limit possible is 5
Increase the limit
Go to website MVP is ready

Information about ICO

Platform Ethereum
Accepted ETH
Start date Oct 10, 2017
End date Nov 8, 2017
Token price 1 MRP =
Released tokens 199 430 728
Soft cap
Hard cap
Raised
Minimal amount 2 MRP
Token MRP - 0.0014175300$ trading
Periods
10.10.2017 08.11.2017
100.00%
MoneyRebel (MRP)
MoneyRebel (MRP)
Token
Ethereum
Utility
ERC-20
Platform: Ethereum
trade -
Main - token distribution
Main - use of funds
Smart contract - Money Rebel
contract SafeMath {
    
    uint256 constant MAX_UINT256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

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

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

    function safeMul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        if (y == 0) {
            return 0;
        }
        require(x <= (MAX_UINT256 / y));
        return x * y;
    }
}
contract TokenRecipientInterface {
  function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public;
}
contract ERC20TokenInterface {
  function totalSupply() public constant returns (uint256 _totalSupply);
  function balanceOf(address _owner) public constant 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 constant returns (uint256 remaining);

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

contract Owned {
    address public owner;
    address public newOwner;

    function Owned() public {
        owner = msg.sender;
    }

    modifier onlyOwner {
        assert(msg.sender == owner);
        _;
    }

    function transferOwnership(address _newOwner) public onlyOwner {
        require(_newOwner != owner);
        newOwner = _newOwner;
    }

    function acceptOwnership() public {
        require(msg.sender == newOwner);
        OwnerUpdate(owner, newOwner);
        owner = newOwner;
        newOwner = 0x0;
    }

    event OwnerUpdate(address _prevOwner, address _newOwner);
}
contract Lockable is Owned {

    uint256 public lockedUntilBlock;

    event ContractLocked(uint256 _untilBlock, string _reason);

    modifier lockAffected {
        require(block.number > lockedUntilBlock);
        _;
    }

    function lockFromSelf(uint256 _untilBlock, string _reason) internal {
        lockedUntilBlock = _untilBlock;
        ContractLocked(_untilBlock, _reason);
    }


    function lockUntil(uint256 _untilBlock, string _reason) onlyOwner public {
        lockedUntilBlock = _untilBlock;
        ContractLocked(_untilBlock, _reason);
    }
}






contract ERC20Token is ERC20TokenInterface, SafeMath, Owned, Lockable {

    /* Public variables of the token */
    string public standard;
    string public name;
    string public symbol;
    uint8 public decimals;

    bool mintingEnabled;

    /* Private variables of the token */
    uint256 supply = 0;
    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowances;

    event Mint(address indexed _to, uint256 _value);
    event Burn(address indexed _from, uint _value);

    /* Returns total supply of issued tokens */
    function totalSupply() constant public returns (uint256) {
        return supply;
    }

    /* Returns balance of address */
    function balanceOf(address _owner) constant public returns (uint256 balance) {
        return balances[_owner];
    }

    /* Transfers tokens from your address to other */
    function transfer(address _to, uint256 _value) lockAffected public returns (bool success) {
        require(_to != 0x0 && _to != address(this));
        balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);  // Deduct senders balance
        balances[_to] = safeAdd(balanceOf(_to), _value);                // Add recivers blaance
        Transfer(msg.sender, _to, _value);                              // Raise Transfer event
        return true;
    }

    /* Approve other address to spend tokens on your account */
    function approve(address _spender, uint256 _value) lockAffected public returns (bool success) {
        allowances[msg.sender][_spender] = _value;        // Set allowance
        Approval(msg.sender, _spender, _value);           // Raise Approval event
        return true;
    }

    /* Approve and then communicate the approved contract in a single tx */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) lockAffected public returns (bool success) {
        TokenRecipientInterface spender = TokenRecipientInterface(_spender);    // Cast spender to tokenRecipient contract
        approve(_spender, _value);                                              // Set approval to contract for _value
        spender.receiveApproval(msg.sender, _value, this, _extraData);          // Raise method on _spender contract
        return true;
    }

    /* A contract attempts to get the coins */
    function transferFrom(address _from, address _to, uint256 _value) lockAffected public returns (bool success) {
        require(_to != 0x0 && _to != address(this));
        balances[_from] = safeSub(balanceOf(_from), _value);                            // Deduct senders balance
        balances[_to] = safeAdd(balanceOf(_to), _value);                                // Add recipient blaance
        allowances[_from][msg.sender] = safeSub(allowances[_from][msg.sender], _value); // Deduct allowance for this address
        Transfer(_from, _to, _value);                                                   // Raise Transfer event
        return true;
    }

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

    /* Owner can mint new tokens while minting is enabled */
    function mint(address _to, uint256 _amount) onlyOwner public {
        require(mintingEnabled);                       // Check if minting is enabled
        supply = safeAdd(supply, _amount);              // Add new token count to totalSupply
        balances[_to] = safeAdd(balances[_to], _amount);// Add tokens to recipients wallet
        Mint(_to, _amount);                             // Raise event that anyone can see
        Transfer(0x0, _to, _amount);                    // Raise transfer event
    }

    /* Anyone can destroy tokens on their walllet */
    function burn(uint _amount) public {
        balances[msg.sender] = safeSub(balanceOf(msg.sender), _amount);
        supply = safeSub(supply, _amount);
        Burn(msg.sender, _amount);
        Transfer(msg.sender, 0x0, _amount);
    }

    /* Owner can salvage tokens that were accidentally sent to the smart contract address */
    function salvageTokensFromContract(address _tokenAddress, address _to, uint _amount) onlyOwner public {
        ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
    }
    
    /* Owner can wipe all the data from the contract and disable all the methods */
    function killContract() onlyOwner public {
        selfdestruct(owner);
    }

    /* Owner can disable minting forever and ever */
    function disableMinting() onlyOwner public {
        mintingEnabled = false;
    }
}




contract MrpToken is ERC20Token {

  /* Initializes contract */
  function MrpToken() public {
    standard = "MoneyRebel token v1.0";
    name = "MrpToken";
    symbol = "MRP";
    decimals = 18;
    mintingEnabled = true;
    lockFromSelf(5010000, "Lock before crowdsale starts");
  }
}
Bitcoin
(-1.54%)
Ethereum
(-1.37%)
Ripple
(-1.84%)
Litecoin
(-1.76%)
EOS
(-0.33%)
Bitcoin Cash
(-1.30%)
Binance Coin
(-2.34%)
Stellar
(-3.68%)
Tether
(0.00%)
Cardano
(-0.47%)
Tronix
(-3.80%)
Bitcoin SV
(-1.24%)
Monero
(-3.62%)
IOTA
(-3.69%)
Dash
(-3.95%)
NEO
(-1.89%)
Ethereum Classic
(-2.05%)
Karatgold coin
(-28.35%)
NEM
(-2.46%)
OKB
(-1.03%)
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