pragmasolidity >=0.4.22<0.6.0;
contractowned{
addresspublicowner;
constructor()public{
owner=msg.sender;
}
modifieronlyOwner{
require(msg.sender==owner);
_;
}
function transferOwnership(addressnewOwner)onlyOwnerpublic{
owner=newOwner;
}
}
interfacetokenRecipient{functionreceiveApproval(address_from,uint256_value,address_token,bytescalldata_extraData)external;}
contractTokenERC20{
// Public variables of the token
stringpublicname;
stringpublicsymbol;
uint8publicdecimals=18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256publictotalSupply;
// This creates an array with all balances
mapping(address=>uint256)publicbalanceOf;
mapping(address=>mapping(address=>uint256))publicallowance;
// This generates a public event on the blockchain that will notify clients
eventTransfer(addressindexedfrom,addressindexedto,uint256value);
// This generates a public event on the blockchain that will notify clients
eventApproval(addressindexed_owner,addressindexed_spender,uint256_value);
// This notifies clients about the amount burnt
eventBurn(addressindexedfrom,uint256value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract */
constructor(
uint256initialSupply,
stringmemorytokenName,
stringmemorytokenSymbol
)
public{
totalSupply=initialSupply * 10 ** uint256(decimals);
// Update total supply with the decimal amount
balanceOf[msg.sender]=totalSupply;
// Give the creator all initial tokens
name=tokenName;
// Set the name for display purposes
symbol=tokenSymbol;
// Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function_transfer(address_from,address_to,uint_value)internal{
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to]+_value>balanceOf[_to]);
// Save this for an assertion in the future
uintpreviousBalances=balanceOf[_from]+balanceOf[_to];
// Subtract from the sender
balanceOf[_from]-=_value;
// Add the same to the recipient
balanceOf[_to]+=_value;
emitTransfer(_from,_to,_value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from]+balanceOf[_to]==previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address_to,uint256_value)public returns(boolsuccess){
_transfer(msg.sender,_to,_value);
return true;
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address_from,address_to,uint256_value)public returns(boolsuccess){
require(_value <= allowance[_from][msg.sender]);
// Check allowance
allowance[_from][msg.sender]-=_value;_
transfer(_from,_to,_value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address_spender,uint256_value)
public returns(boolsuccess){
allowance[msg.sender][_spender]=_value;
emitApproval(msg.sender,_spender,_value);
returntrue;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address_spender,uint256_value,bytesmemory_extraData)
public
returns(boolsuccess){tokenRecipientspender=tokenRecipient(_spender);
if(approve(_spender,_value)){
spender.receiveApproval(msg.sender,_value,address(this),_extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256_value)public returns(boolsuccess){
require(balanceOf[msg.sender] >= _value);
// Check if the sender has enough
balanceOf[msg.sender]-=_value;
// Subtract from the sender
totalSupply-=_value;
// Updates totalSupply
emit Burn(msg.sender,_value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address_from,uint256_value)
public returns(boolsuccess){
require(balanceOf[_from] >= _value);
// Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]);
// Check allowance
balanceOf[_from]-=_value;
// Subtract from the targeted balance
allowance[_from][msg.sender]-=_value;
// Subtract from the sender's allowance
totalSupply-=_value;
// Update totalSupply
emit Burn(_from,_value);
returntrue;
}
}
/******************************************//*
ADVANCED TOKEN STARTS HERE *//******************************************/
contract SibiCoin isowned,TokenERC20{
uint256publicsellPrice;
uint256publicbuyPrice;
mapping(address=>bool)publicfrozenAccount;
/* This generates a public event on the blockchain that will notify clients
*/
event FrozenFunds(addresstarget,boolfrozen);
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor(
uint256initialSupply,
stringmemorytokenName,
stringmemorytokenSymbol)
TokenERC20(initialSupply,tokenName,tokenSymbol)public{}
/* Internal transfer, only can be called by this contract */
function_transfer(address_from,address_to,uint_value)internal{
require(_to != address(0x0));
// Prevent transfer to 0x0 address. Use burn() instead
require(balanceOf[_from] >= _value);
// Check if the sender has enough
require(balanceOf[_to]+_value >= balanceOf[_to]);
// Check for overflows
require(!frozenAccount[_from]);
// Check if sender is frozen
require(!frozenAccount[_to]);
// Check if recipient is frozen
balanceOf[_from]-=_value;
// Subtract from the sender
balanceOf[_to]+=_value;
// Add the same to the recipient
emit Transfer(_from,_to,_value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target,uint256mintedAmount)
onlyOwner public{
balanceOf[target]+=mintedAmount;
totalSupply+=mintedAmount;
emit Transfer(address(0),address(this),mintedAmount);
emit Transfer(address(this),target,mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen/// @param freeze either to freeze it or not
function freezeAccount(addresstarget,boolfreeze)onlyOwner public{
frozenAccount[target]=freeze;
emit FrozenFunds(target,freeze);
}
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256newSellPrice, uint256newBuyPrice)
onlyOwner public{
sellPrice=newSellPrice;
buyPrice=newBuyPrice;
}
/// @notice Buy tokens from contract by sending ether
function buy()payablepublic{uintamount=msg.value / buyPrice;
// calculates the amount
_transfer(address(this),msg.sender,amount);
// makes the transfers
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256amount)public{addressmyAddress=address(this);
require(myAddress.balance >= amount * sellPrice);
// checks if the contract has enough ether to buy
_transfer(msg.sender,address(this),amount);
// makes the transfers
msg.sender.transfer(amount * sellPrice);
// sends ether to the seller. It's important to do this last to avoid recursion attacks
}
}top of page
Search
bottom of page