Spaces:
Runtime error
Runtime error
File size: 4,810 Bytes
ee7776a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 |
/**
*Submitted for verification at Etherscan.io on 2018-01-17
*/
pragma solidity ^0.4.19;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract SafeMath {
function safeMul(uint256 a, uint256 b) returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
function safeSub(uint256 a, uint256 b) returns (uint256) {
require(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) returns (uint256) {
uint c = a + b;
require(c >= a && c >= b);
return c;
}
}
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
function setOwner(address _owner) returns (bool success) {
owner = _owner;
return true;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract AURA is SafeMath, Owned {
bool public locked = true;
string public name = "Aurora DAO";
string public symbol = "AURA";
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* Constructor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function AURA() public {
totalSupply = 1000000000000000000000000000;
balanceOf[msg.sender] = totalSupply;
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
require(!locked || msg.sender == owner);
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
require(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
require(!locked);
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function unlockToken() onlyOwner {
locked = false;
}
bool public balancesUploaded = false;
function uploadBalances(address[] recipients, uint256[] balances) onlyOwner {
require(!balancesUploaded);
uint256 sum = 0;
for (uint256 i = 0; i < recipients.length; i++) {
balanceOf[recipients[i]] = safeAdd(balanceOf[recipients[i]], balances[i]);
sum = safeAdd(sum, balances[i]);
}
balanceOf[owner] = safeSub(balanceOf[owner], sum);
}
function lockBalances() onlyOwner {
balancesUploaded = true;
}
} |