Created
October 10, 2018 14:50
-
-
Save Sledro/62fed34409b9a68534986df7629e0dad to your computer and use it in GitHub Desktop.
Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.4.25+commit.59dbf8f1.js&optimize=false&gist=
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
pragma solidity ^0.4.11; | |
import "./SafeMath.sol"; | |
// ---------------------------------------------------------------------------- | |
// Owned contract | |
// ---------------------------------------------------------------------------- | |
contract Owned { | |
address public owner; | |
address public newOwner; | |
event OwnershipTransferred(address indexed _from, address indexed _to); | |
constructor() public { | |
owner = msg.sender; | |
} | |
modifier onlyOwner { | |
require(msg.sender == owner); | |
_; | |
} | |
function transferOwnership(address _newOwner) public onlyOwner { | |
newOwner = _newOwner; | |
} | |
function acceptOwnership() public { | |
require(msg.sender == newOwner); | |
emit OwnershipTransferred(owner, newOwner); | |
owner = newOwner; | |
newOwner = address(0); | |
} | |
} | |
contract ERC223 { | |
uint public totalSupply; | |
function balanceOf(address who) constant returns (uint); | |
function name() constant returns (string _name); | |
function symbol() constant returns (string _symbol); | |
function decimals() constant returns (uint8 _decimals); | |
function totalSupply() constant returns (uint256 _supply); | |
function transfer(address to, uint value) returns (bool ok); | |
function transfer(address to, uint value, bytes data) returns (bool ok); | |
event Transfer(address indexed _from, address indexed _to, uint256 _value); | |
event ERC223Transfer(address indexed _from, address indexed _to, uint256 _value, bytes _data); | |
} | |
contract ContractReceiver { | |
function tokenFallback(address _from, uint _value, bytes _data); | |
} | |
contract ERC223Token is ERC223 { | |
using SafeMath for uint; | |
mapping(address => uint) balances; | |
string public name; | |
string public symbol; | |
uint8 public decimals; | |
uint256 public totalSupply; | |
// Function to access name of token . | |
function name() constant returns (string _name) { | |
return name; | |
} | |
// Function to access symbol of token . | |
function symbol() constant returns (string _symbol) { | |
return symbol; | |
} | |
// Function to access decimals of token . | |
function decimals() constant returns (uint8 _decimals) { | |
return decimals; | |
} | |
// Function to access total supply of tokens . | |
function totalSupply() constant returns (uint256 _totalSupply) { | |
return totalSupply; | |
} | |
// Function that is called when a user or another contract wants to transfer funds . | |
function transfer(address _to, uint _value, bytes _data) returns (bool success) { | |
if(isContract(_to)) { | |
return transferToContract(_to, _value, _data); | |
} | |
else { | |
return transferToAddress(_to, _value, _data); | |
} | |
} | |
// Standard function transfer similar to ERC20 transfer with no _data . | |
// Added due to backwards compatibility reasons . | |
function transfer(address _to, uint _value) returns (bool success) { | |
//standard function transfer similar to ERC20 transfer with no _data | |
//added due to backwards compatibility reasons | |
bytes memory empty; | |
if(isContract(_to)) { | |
return transferToContract(_to, _value, empty); | |
} | |
else { | |
return transferToAddress(_to, _value, empty); | |
} | |
} | |
//assemble the given address bytecode. If bytecode exists then the _addr is a contract. | |
function isContract(address _addr) private returns (bool is_contract) { | |
uint length; | |
assembly { | |
//retrieve the size of the code on target address, this needs assembly | |
length := extcodesize(_addr) | |
} | |
if(length>0) { | |
return true; | |
} | |
else { | |
return false; | |
} | |
} | |
//function that is called when transaction target is an address | |
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) { | |
if (balanceOf(msg.sender) < _value) revert(); | |
balances[msg.sender] = balanceOf(msg.sender).sub(_value); | |
balances[_to] = balanceOf(_to).add(_value); | |
Transfer(msg.sender, _to, _value); | |
ERC223Transfer(msg.sender, _to, _value, _data); | |
return true; | |
} | |
//function that is called when transaction target is a contract | |
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) { | |
if (balanceOf(msg.sender) < _value) revert(); | |
balances[msg.sender] = balanceOf(msg.sender).sub(_value); | |
balances[_to] = balanceOf(_to).add(_value); | |
ContractReceiver reciever = ContractReceiver(_to); | |
reciever.tokenFallback(msg.sender, _value, _data); | |
Transfer(msg.sender, _to, _value); | |
ERC223Transfer(msg.sender, _to, _value, _data); | |
return true; | |
} | |
function balanceOf(address _owner) constant returns (uint balance) { | |
return balances[_owner]; | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
pragma solidity ^0.4.18; | |
import "./ERC223.sol"; | |
contract GoodGamePlatform is ERC223Token, Owned { | |
string public name = "GoodGamePlatform"; | |
string public symbol = "GGP"; | |
uint public decimals = 18; | |
uint public totalSupply = 1000000000 * 10**uint(decimals); | |
function GoodGamePlatform() { | |
balances[owner] = totalSupply; | |
emit Transfer(address(0), owner, totalSupply); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
pragma solidity ^0.4.18; | |
/** | |
* @title SafeMath | |
* @dev Math operations with safety checks that throw on error | |
*/ | |
library SafeMath { | |
/** | |
* @dev Multiplies two numbers, throws on overflow. | |
*/ | |
function mul(uint256 a, uint256 b) internal pure returns (uint256) { | |
if (a == 0) { | |
return 0; | |
} | |
uint256 c = a * b; | |
assert(c / a == b); | |
return c; | |
} | |
/** | |
* @dev Integer division of two numbers, truncating the quotient. | |
*/ | |
function div(uint256 a, uint256 b) internal pure returns (uint256) { | |
// assert(b > 0); // Solidity automatically throws when dividing by 0 | |
uint256 c = a / b; | |
// assert(a == b * c + a % b); // There is no case in which this doesn't hold | |
return c; | |
} | |
/** | |
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). | |
*/ | |
function sub(uint256 a, uint256 b) internal pure returns (uint256) { | |
assert(b <= a); | |
return a - b; | |
} | |
/** | |
* @dev Adds two numbers, throws on overflow. | |
*/ | |
function add(uint256 a, uint256 b) internal pure returns (uint256) { | |
uint256 c = a + b; | |
assert(c >= a); | |
return c; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment