English
USD
Popular
Other
STIGAMMA
STIGAMMA
ICO
FIRST GLOBAL DECENTRALIZED PLATFORM FOR TRADE OPTIONS(Degital Outperformance Option)
Category: Platform, Business services
Founded: Jan 14, 2018
Country: Serbia
Sadly, you’ve exceeded the limit of adding to favorite.
The limit possible is 5
Increase the limit
Go to website MVP is ready
Registered on Neironix

Information about ICO

Platform Ethereum
Accepted BTC, ETH, WAVES
Start date Jan 15, 2018
End date Jul 1, 2018
Soft cap
Hard cap
Minimal amount 1 DCA
Token DCA
Periods
15.01.2018 01.07.2018
100.00%
DoBETacceptBEt(DCA) (DCA)
DoBETacceptBEt(DCA) (DCA)
Token
Ethereum
Utility
ERC-20
Platform: Ethereum
Not trade
STIGAMMA - token distribution
DCA Token is created on the platform Ethereum ERC20 contract number: 0x386Faa4703a34a7Fdb19Bec2e14Fd427C9638416 Token Holder: 0x7dbb125435e98518154804911a42d8f8771ca5cd
Smart contract - STIGAMMA
pragma solidity ^0.4.18;

contract owned {
    address public owner;
    function owned() public {
        owner = msg.sender;
    }
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    function transferOwnership(address newOwner) onlyOwner public {
        owner = newOwner;
    }
}
contract TokenERC20 is owned {
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    
    uint256 public totalSupply;
    uint public amountRaised;

    uint256 public sellPrice;
    uint256 public buyPrice;
    bool public lockedSell;
    
    bytes32 public currentChallenge;
    uint public timeOfLastProof;
    uint public difficulty = 10**32;
    
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;


    event Transfer(address indexed from, address indexed to, uint256 value);
    event Burn(address indexed from, uint256 value);
    event Freeze(address from, uint256 amount);
    event UnFreeze(address to, uint256 amount);
        
    function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol, uint256 newSellPrice, uint256 newBuyPrice) public {
        totalSupply = initialSupply * 10 ** uint256(decimals);  
        balanceOf[msg.sender] = totalSupply;                
        name = tokenName;                                   
        symbol = tokenSymbol;                               
        owner = msg.sender;
        timeOfLastProof = now;
        sellPrice = newSellPrice;
        buyPrice = newBuyPrice;
        lockedSell = true;
    }

    function emission(uint256 amount) onlyOwner public {
        totalSupply += amount;
        balanceOf[msg.sender] += amount;
    } 
    
    function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
        sellPrice = newSellPrice;
        buyPrice = newBuyPrice;
    }
    
    function buy() public payable returns (uint amount) {
        amount = (msg.value * 10 ** uint256(decimals)) / buyPrice;
        require(balanceOf[owner] >= amount);               
        balanceOf[msg.sender] += amount;                  
        balanceOf[owner] -= amount;                        
        amountRaised += msg.value;
        Transfer(owner, msg.sender, amount);               
        return amount;                                    
    }

    function sell(uint amount) public returns (uint revenue) {
        require(!lockedSell);
        require(balanceOf[msg.sender] >= amount);         
        balanceOf[owner] += amount;                        
        balanceOf[msg.sender] -= amount;  
        revenue = amount * sellPrice / 10 ** uint256(decimals);
        amountRaised -= revenue;
        require(msg.sender.send(revenue));                
        Transfer(msg.sender, owner, amount);               
        return revenue;                                   
    }

    function lockSell(bool value) onlyOwner public {
        lockedSell = value;
    }

    function proofOfWork(uint nonce) public {
        bytes8 n = bytes8(keccak256(nonce, currentChallenge));    
        require(n >= bytes8(difficulty));                   

        uint timeSinceLastProof = (now - timeOfLastProof);  
        require(timeSinceLastProof >= 5 seconds);         
        balanceOf[msg.sender] += timeSinceLastProof / 60 seconds;  

        difficulty = difficulty * 10 minutes / timeSinceLastProof + 1;  

        timeOfLastProof = now;                              
        currentChallenge = keccak256(nonce, currentChallenge, block.blockhash(block.number - 1));  
    }
    
    function _transfer(address from, address to, uint amount) internal {
        require(to != 0x0);
        require(balanceOf[from] >= amount);
        require(balanceOf[to] + amount > balanceOf[to]);
        uint previousBalances = balanceOf[from] + balanceOf[to];
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        Transfer(from, to, amount);
        assert(balanceOf[from] + balanceOf[to] == previousBalances);
    }
    
    function transfer(address to, uint256 amount) public {
        _transfer(msg.sender, to, amount);
    }
    
    function transferFrom(address from, address to, uint256 amount) public returns (bool success) {
        require(amount <= allowance[from][msg.sender]);
        allowance[from][msg.sender] -= amount;
        _transfer(from, to, amount);
        return true;
    }

    function approve(address spender, uint256 amount) public returns (bool success) {
        allowance[msg.sender][spender] = amount;
        return true;
    }
    
    function burn(uint256 amount) public returns (bool success) {
        require(balanceOf[msg.sender] >= amount);   
        balanceOf[msg.sender] -= amount;            
        totalSupply -= amount;                      
        Burn(msg.sender, amount);
        return true;
    }

    function burnFrom(address from, uint256 amount) public returns (bool success) {
        require(balanceOf[from] >= amount);
        require(amount <= allowance[from][msg.sender]);
        balanceOf[from] -= amount;
        allowance[from][msg.sender] -= amount;
        totalSupply -= amount;
        Burn(from, amount);
        return true;
    }

    function withdrawRaised(uint amount) onlyOwner public {
        require(amountRaised >= amount);
        if (owner.send(amount))
            amountRaised -= amount;
    }

    function freeze(address from, uint256 amount) onlyOwner public returns (bool success){
        require(amount <= allowance[from][this]);
        allowance[from][this] -= amount;
        _transfer(from, this, amount);
        Freeze(from, amount);
        return true;
    }

    function unFreeze(address to, uint256 amount) onlyOwner public returns (bool success){
        _transfer(this, to, amount);
        UnFreeze(to, amount);
        return true;
    }
}
Bitcoin
(4.00%)
Ethereum
(5.95%)
Ripple
(-1.43%)
Bitcoin Cash
(3.48%)
Tether
(-0.70%)
Bitcoin SV
(1.59%)
Litecoin
(1.91%)
Binance Coin
(1.22%)
EOS
(-0.28%)
Tezos
(3.31%)
Cardano
(17.74%)
ChainLink
(-1.32%)
Stellar
(3.48%)
Bitfinex LEO Token
(-4.42%)
Monero
(4.54%)
Huobi Token
(3.18%)
Sola
(-2.16%)
Tron
(3.99%)
Crypto.com Chain
(7.65%)
AXenS
(-2.76%)
Support Center
Tracking of cryptocurrency markets has become even more convenient with our application.
Neironix Mobile App
Download for FREE
Download App
Create account
Sign in
Contact technical support
If you have any problems with the system, please describe the problem in the form below, or send your question to: support@neironix.io