Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
SAT_Smart_Contract/SocialActivityToken_Smart_Contract.sol
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
381 lines (298 sloc)
11.7 KB
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
/* | |
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); | |
} | |
} |