Permalink
Cannot retrieve contributors at this time
/* | |
Social Activity Token (SAT) - Official Smart Contract | |
Sphere Social LTD | |
https://sphere.social | |
*/ | |
pragma solidity 0.4.19; | |
/** | |
* @title SafeMath | |
* @dev Math operations with safety checks that throw on error | |
*/ | |
library SafeMath { | |
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; | |
} | |
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; | |
} | |
function sub(uint256 a, uint256 b) internal pure returns (uint256) { | |
assert(b <= a); | |
return a - b; | |
} | |
function add(uint256 a, uint256 b) internal pure returns (uint256) { | |
uint256 c = a + b; | |
assert(c >= a); | |
return c; | |
} | |
} | |
contract ERC20 { | |
function totalSupply()public view returns (uint total_Supply); | |
function balanceOf(address who)public view returns (uint256); | |
function allowance(address owner, address spender)public view returns (uint); | |
function transferFrom(address from, address to, uint value)public returns (bool ok); | |
function approve(address spender, uint value)public returns (bool ok); | |
function transfer(address to, uint value)public returns (bool ok); | |
event Transfer(address indexed from, address indexed to, uint value); | |
event Approval(address indexed owner, address indexed spender, uint value); | |
} | |
contract FiatContract | |
{ | |
function USD(uint _id) constant returns (uint256); | |
} | |
contract SocialActivityToken is ERC20 | |
{ | |
using SafeMath for uint256; | |
FiatContract price = FiatContract(0x8055d0504666e2B6942BeB8D6014c964658Ca591); // MAINNET ADDRESS | |
// Name of the token | |
string public constant name = "Social Activity Token"; | |
// Symbol of token | |
string public constant symbol = "SAT"; | |
uint8 public constant decimals = 8; | |
uint public _totalsupply = 1000000000 * (uint256(10) ** decimals); // 1 billion SAT | |
address public owner; | |
bool stopped = false; | |
uint256 public startdate; | |
uint256 ico_first; | |
uint256 ico_second; | |
uint256 ico_third; | |
uint256 ico_fourth; | |
address central_account; | |
mapping(address => uint) balances; | |
mapping(address => mapping(address => uint)) allowed; | |
enum Stages { | |
NOTSTARTED, | |
ICO, | |
PAUSED, | |
ENDED | |
} | |
Stages public stage; | |
modifier atStage(Stages _stage) { | |
if (stage != _stage) | |
// Contract not in expected state | |
revert(); | |
_; | |
} | |
modifier onlyOwner() { | |
if (msg.sender != owner) { | |
revert(); | |
} | |
_; | |
} | |
modifier onlycentralAccount { | |
require(msg.sender == central_account); | |
_; | |
} | |
function SocialActivityToken() public | |
{ | |
owner = msg.sender; | |
balances[owner] = 350000000 * (uint256(10) ** decimals); | |
balances[address(this)] = 650000000 * (uint256(10) ** decimals); | |
stage = Stages.NOTSTARTED; | |
Transfer(0, owner, balances[owner]); | |
Transfer(0, address(this), balances[address(this)]); | |
} | |
function () public payable atStage(Stages.ICO) | |
{ | |
require(msg.value >= 1 finney); //for round up and security measures | |
require(!stopped && msg.sender != owner); | |
uint256 ethCent = price.USD(0); //one USD cent in wei | |
uint256 tokPrice = ethCent.mul(14); //1Sat = 14 USD cent | |
tokPrice = tokPrice.div(10 ** 8); //limit to 10 places | |
uint256 no_of_tokens = msg.value.div(tokPrice); | |
uint256 bonus_token = 0; | |
// Determine the bonus based on the time and the purchased amount | |
if (now < ico_first) | |
{ | |
if (no_of_tokens >= 2000 * (uint256(10)**decimals) && | |
no_of_tokens <= 19999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(50).div(100); // 50% bonus | |
} | |
else if (no_of_tokens > 19999 * (uint256(10)**decimals) && | |
no_of_tokens <= 149999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(55).div(100); // 55% bonus | |
} | |
else if (no_of_tokens > 149999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(60).div(100); // 60% bonus | |
} | |
else | |
{ | |
bonus_token = no_of_tokens.mul(45).div(100); // 45% bonus | |
} | |
} | |
else if (now >= ico_first && now < ico_second) | |
{ | |
if (no_of_tokens >= 2000 * (uint256(10)**decimals) && | |
no_of_tokens <= 19999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(40).div(100); // 40% bonus | |
} | |
else if (no_of_tokens > 19999 * (uint256(10)**decimals) && | |
no_of_tokens <= 149999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(45).div(100); // 45% bonus | |
} | |
else if (no_of_tokens > 149999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(50).div(100); // 50% bonus | |
} | |
else | |
{ | |
bonus_token = no_of_tokens.mul(35).div(100); // 35% bonus | |
} | |
} | |
else if (now >= ico_second && now < ico_third) | |
{ | |
if (no_of_tokens >= 2000 * (uint256(10)**decimals) && | |
no_of_tokens <= 19999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(30).div(100); // 30% bonus | |
} | |
else if (no_of_tokens > 19999 * (uint256(10)**decimals) && | |
no_of_tokens <= 149999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(35).div(100); // 35% bonus | |
} | |
else if (no_of_tokens > 149999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(40).div(100); // 40% bonus | |
} | |
else | |
{ | |
bonus_token = no_of_tokens.mul(25).div(100); // 25% bonus | |
} | |
} | |
else if (now >= ico_third && now < ico_fourth) | |
{ | |
if (no_of_tokens >= 2000 * (uint256(10)**decimals) && | |
no_of_tokens <= 19999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(20).div(100); // 20% bonus | |
} | |
else if (no_of_tokens > 19999 * (uint256(10)**decimals) && | |
no_of_tokens <= 149999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(25).div(100); // 25% bonus | |
} | |
else if (no_of_tokens > 149999 * (uint256(10)**decimals)) | |
{ | |
bonus_token = no_of_tokens.mul(30).div(100); // 30% bonus | |
} | |
else | |
{ | |
bonus_token = no_of_tokens.mul(15).div(100); // 15% bonus | |
} | |
} | |
uint256 total_token = no_of_tokens + bonus_token; | |
this.transfer(msg.sender, total_token); | |
} | |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED) { | |
stage = Stages.ICO; | |
stopped = false; | |
startdate = now; | |
ico_first = now + 14 days; | |
ico_second = ico_first + 14 days; | |
ico_third = ico_second + 14 days; | |
ico_fourth = ico_third + 14 days; | |
} | |
// called by the owner, pause ICO | |
function StopICO() external onlyOwner atStage(Stages.ICO) { | |
stopped = true; | |
stage = Stages.PAUSED; | |
} | |
// called by the owner , resumes ICO | |
function releaseICO() external onlyOwner atStage(Stages.PAUSED) { | |
stopped = false; | |
stage = Stages.ICO; | |
} | |
function end_ICO() external onlyOwner atStage(Stages.ICO) { | |
require(now > ico_fourth); | |
stage = Stages.ENDED; | |
} | |
function burn(uint256 _amount) external onlyOwner | |
{ | |
require(_amount <= balances[address(this)]); | |
_totalsupply = _totalsupply.sub(_amount); | |
balances[address(this)] = balances[address(this)].sub(_amount); | |
balances[0x0] = balances[0x0].add(_amount); | |
Transfer(address(this), 0x0, _amount); | |
} | |
function set_centralAccount(address central_Acccount) external onlyOwner { | |
central_account = central_Acccount; | |
} | |
// what is the total supply of SAT | |
function totalSupply() public view returns (uint256 total_Supply) { | |
total_Supply = _totalsupply; | |
} | |
// What is the balance of a particular account? | |
function balanceOf(address _owner)public view returns (uint256 balance) { | |
return balances[_owner]; | |
} | |
// Send _value amount of tokens from address _from to address _to | |
// The transferFrom method is used for a withdraw workflow, allowing contracts to send | |
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge | |
// fees in sub-currencies; the command should fail unless the _from account has | |
// deliberately authorized the sender of the message via some mechanism; we propose | |
// these standardized APIs for approval: | |
function transferFrom( address _from, address _to, uint256 _amount )public returns (bool success) { | |
require( _to != 0x0); | |
balances[_from] = balances[_from].sub(_amount); | |
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount); | |
balances[_to] = balances[_to].add(_amount); | |
Transfer(_from, _to, _amount); | |
return true; | |
} | |
// Allow _spender to withdraw from your account, multiple times, up to the _value amount. | |
// If this function is called again it overwrites the current allowance with _value. | |
function approve(address _spender, uint256 _amount)public returns (bool success) { | |
require(_amount == 0 || allowed[msg.sender][_spender] == 0); | |
require( _spender != 0x0); | |
allowed[msg.sender][_spender] = _amount; | |
Approval(msg.sender, _spender, _amount); | |
return true; | |
} | |
function allowance(address _owner, address _spender)public view returns (uint256 remaining) { | |
require( _owner != 0x0 && _spender !=0x0); | |
return allowed[_owner][_spender]; | |
} | |
// Transfer the balance from owner's account to another account | |
function transfer(address _to, uint256 _amount)public returns (bool success) { | |
require( _to != 0x0); | |
balances[msg.sender] = balances[msg.sender].sub(_amount); | |
balances[_to] = balances[_to].add(_amount); | |
Transfer(msg.sender, _to, _amount); | |
return true; | |
} | |
function transferby(address _from,address _to,uint256 _amount) external onlycentralAccount returns(bool success) { | |
require( _to != 0x0); | |
// Only allow transferby() to transfer from 0x0 and the ICO account | |
require(_from == address(this)); | |
balances[_from] = (balances[_from]).sub(_amount); | |
balances[_to] = (balances[_to]).add(_amount); | |
if (_from == 0x0) | |
{ | |
_totalsupply = _totalsupply.add(_amount); | |
} | |
Transfer(_from, _to, _amount); | |
return true; | |
} | |
//In case the ownership needs to be transferred | |
function transferOwnership(address newOwner)public onlyOwner { | |
balances[newOwner] = balances[newOwner].add(balances[owner]); | |
balances[owner] = 0; | |
owner = newOwner; | |
} | |
function drain() external onlyOwner { | |
owner.transfer(this.balance); | |
} | |
} |