Transaction Hash:
Block:
19632262 at Apr-11-2024 12:04:35 PM +UTC
Transaction Fee:
0.001130988946652418 ETH
$4.30
Gas Used:
46,419 Gas / 24.364784822 Gwei
Emitted Events:
216 |
CrypteriumToken.Approval( owner=[Sender] 0xae59e31786a9f594b5cf2ad2cc889f4d93bb06d5, spender=0xC36442b4...7Ab11FE88, value=115792089237316195423570985008687907853269984665640564039457584007913129639935 )
|
Account State Difference:
Address | Before | After | State Difference | ||
---|---|---|---|---|---|
0x4838B106...B0BAD5f97
Miner
| (Titan Builder) | 9.081418048795794867 Eth | 9.081419076155956947 Eth | 0.00000102736016208 | |
0x80A7E048...6fA3baE7f | |||||
0xAe59E317...d93bb06D5 |
5.5 Eth
Nonce: 0
|
5.498869011053347582 Eth
Nonce: 1
| 0.001130988946652418 |
Execution Trace
CrypteriumToken.approve( _spender=0xC36442b4a4522E871399CD717aBDD847Ab11FE88, _value=115792089237316195423570985008687907853269984665640564039457584007913129639935 ) => ( True )
approve[CrypteriumToken (ln:103)]
Approval[CrypteriumToken (ln:110)]
pragma solidity ^0.4.16; /** * @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() public { 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 public { require(newOwner != address(0)); owner = newOwner; } } contract CrypteriumToken is Ownable { uint256 public totalSupply; mapping(address => uint256) balances; mapping(address => mapping(address => uint256)) allowed; string public constant name = "CrypteriumToken"; string public constant symbol = "CRPT"; uint32 public constant decimals = 18; uint constant restrictedPercent = 30; //should never be set above 100 address constant restricted = 0x1d907C982B0B093b5173574FAbe7965181522c7B; uint constant start = 1509458400; uint constant period = 87; uint256 public constant hardcap = 300000000 * 1 ether; bool public transferAllowed = false; bool public mintingFinished = false; modifier whenTransferAllowed() { if(msg.sender != owner){ require(transferAllowed); } _; } modifier saleIsOn() { require(now > start && now < start + period * 1 days); _; } modifier canMint() { require(!mintingFinished); _; } function transfer(address _to, uint256 _value) whenTransferAllowed public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender] - _value; balances[_to] = balances[_to] + _value; //assert(balances[_to] >= _value); no need to check, since mint has limited hardcap Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) constant public returns (uint256 balance) { return balances[_owner]; } function transferFrom(address _from, address _to, uint256 _value) whenTransferAllowed public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from] - _value; balances[_to] = balances[_to] + _value; //assert(balances[_to] >= _value); no need to check, since mint has limited hardcap allowed[_from][msg.sender] = allowed[_from][msg.sender] - _value; Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { //NOTE: To prevent attack vectors like the one discussed here: //https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729, //clients SHOULD make sure to create user interfaces in such a way //that they set the allowance first to 0 before setting it to another value for the same spender. allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } function allowTransfer() onlyOwner public { transferAllowed = true; } function mint(address _to, uint256 _value) onlyOwner saleIsOn canMint public returns (bool) { require(_to != address(0)); uint restrictedTokens = _value * restrictedPercent / (100 - restrictedPercent); uint _amount = _value + restrictedTokens; assert(_amount >= _value); if(_amount + totalSupply <= hardcap){ totalSupply = totalSupply + _amount; assert(totalSupply >= _amount); balances[msg.sender] = balances[msg.sender] + _amount; assert(balances[msg.sender] >= _amount); Mint(msg.sender, _amount); transfer(_to, _value); transfer(restricted, restrictedTokens); } return true; } function finishMinting() onlyOwner public returns (bool) { mintingFinished = true; MintFinished(); return true; } /** * @dev Burns a specific amount of tokens. * @param _value The amount of token to be burned. */ function burn(uint256 _value) public returns (bool) { require(_value <= balances[msg.sender]); // no need to require value <= totalSupply, since that would imply the // sender's balance is greater than the totalSupply, which *should* be an assertion failure balances[msg.sender] = balances[msg.sender] - _value; totalSupply = totalSupply - _value; Burn(msg.sender, _value); return true; } function burnFrom(address _from, uint256 _value) public returns (bool success) { require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from] - _value; allowed[_from][msg.sender] = allowed[_from][msg.sender] - _value; totalSupply = totalSupply - _value; Burn(_from, _value); return true; } event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); event Mint(address indexed to, uint256 amount); event MintFinished(); event Burn(address indexed burner, uint256 value); }