Quote from: BalletDev on August 30, 2018, 07:22:35 PM

The Ballet Foundations mission is cultural enrichment and access to ballet for the community, the dance patron, and the dancer by improving training, performance, personal coaching and career opportunities for serious ballet students. It is our mission to open this opportunity to all without financial restrictions and to develop young lives with the discipline that comes from the arts inside a Christian principled environment.

Incidental to the Ballet Foundations primary activity, it develops ballet jury adjudications and produces a regular ballet performance season composed of students and professional artists.

To ultimately fulfill this mission, the Ballet Foundation strives to use artistic expression through dance as a ministry to reach hearts and a means to praise God.

Code:

pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------

// 'Ballet (BALLET)' 'Fixed Supply Token' token contract

//

// Symbol : BALLET

// Name : Ballet

// Decimals : 18

//

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

// Safe maths

// ----------------------------------------------------------------------------

library SafeMath {

   function add(uint a, uint b) internal pure returns (uint c) {

   c = a + b;

   require(c >= a);

   }

   function sub(uint a, uint b) internal pure returns (uint c) {

   require(b <= a);

   c = a - b;

   }

   function mul(uint a, uint b) internal pure returns (uint c) {

   c = a * b;

   require(a == 0 || c / a == b);

   }

   function div(uint a, uint b) internal pure returns (uint c) {

   require(b > 0);

   c = a / b;

   }

}

// ----------------------------------------------------------------------------

// ERC Token Standard #20 Interface

// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md

// ----------------------------------------------------------------------------

contract ERC20Interface {

   function totalSupply() public constant returns (uint);

   function balanceOf(address tokenOwner) public constant returns (uint balance);

   function allowance(address tokenOwner, address spender) public constant returns (uint remaining);

   function transfer(address to, uint tokens) public returns (bool success);

   function approve(address spender, uint tokens) public returns (bool success);

   function transferFrom(address from, address to, uint tokens) public returns (bool success);

   event Transfer(address indexed from, address indexed to, uint tokens);

   event Approval(address indexed tokenOwner, address indexed spender, uint tokens);

}

// ----------------------------------------------------------------------------

// Contract function to receive approval and execute function in one call

// ----------------------------------------------------------------------------

contract ApproveAndCallFallBack {

   function receiveApproval(address from, uint256 tokens, address token, bytes data) public;

}

// ----------------------------------------------------------------------------

// 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);

   }

}

// ----------------------------------------------------------------------------

// ERC20 Token, with the addition of symbol, name and decimals and a

// fixed supply

// ----------------------------------------------------------------------------

contract BALLET is ERC20Interface, Owned {

   using SafeMath for uint;

   string public symbol;

   string public name;

   uint8 public decimals;

   uint _totalSupply;

   mapping(address => uint) balances;

   mapping(address => mapping(address => uint)) allowed;

   // ------------------------------------------------------------------------

   // Constructor

   // ------------------------------------------------------------------------

   constructor() public {

   symbol = "BALLET";

   name = "Ballet Token";

   decimals = 18;

   _totalSupply = 1000000000000000 * 10**uint(decimals);

   balances[owner] = _totalSupply;

   emit Transfer(address(0), owner, _totalSupply);

   }

   // ------------------------------------------------------------------------

   // Total supply

   // ------------------------------------------------------------------------

   function totalSupply() public view returns (uint) {

   return _totalSupply.sub(balances[address(0)]);

   }

   // ------------------------------------------------------------------------

   // Get the token balance for account `tokenOwner`

   // ------------------------------------------------------------------------

   function balanceOf(address tokenOwner) public view returns (uint balance) {

   return balances[tokenOwner];

   }

   // ------------------------------------------------------------------------

   // Transfer the balance from token owner's account to `to` account

   // - Owner's account must have sufficient balance to transfer

   // - 0 value transfers are allowed

   // ------------------------------------------------------------------------

   function transfer(address to, uint tokens) public returns (bool success) {

   balances[msg.sender] = balances[msg.sender].sub(tokens);

   balances[to] = balances[to].add(tokens);

   emit Transfer(msg.sender, to, tokens);

   return true;

   }

   // ------------------------------------------------------------------------

   // Token owner can approve for `spender` to transferFrom(...) `tokens`

   // from the token owner's account

   //

   // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md

   // recommends that there are no checks for the approval double-spend attack

   // as this should be implemented in user interfaces

   // ------------------------------------------------------------------------

   function approve(address spender, uint tokens) public returns (bool success) {

   allowed[msg.sender][spender] = tokens;

   emit Approval(msg.sender, spender, tokens);

   return true;

   }

   // ------------------------------------------------------------------------

   // Transfer `tokens` from the `from` account to the `to` account

   //

   // The calling account must already have sufficient tokens approve(...)-d

   // for spending from the `from` account and

   // - From account must have sufficient balance to transfer

   // - Spender must have sufficient allowance to transfer

   // - 0 value transfers are allowed

   // ------------------------------------------------------------------------

   function transferFrom(address from, address to, uint tokens) public returns (bool success) {

   balances[from] = balances[from].sub(tokens);

   allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);

   balances[to] = balances[to].add(tokens);

   emit Transfer(from, to, tokens);

   return true;

   }

   // ------------------------------------------------------------------------

   // Returns the amount of tokens approved by the owner that can be

   // transferred to the spender's account

   // ------------------------------------------------------------------------

   function allowance(address tokenOwner, address spender) public view returns (uint remaining) {

   return allowed[tokenOwner][spender];

   }

   // ------------------------------------------------------------------------

   // Token owner can approve for `spender` to transferFrom(...) `tokens`

   // from the token owner's account. The `spender` contract function

   // `receiveApproval(...)` is then executed

   // ------------------------------------------------------------------------

   function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {

   allowed[msg.sender][spender] = tokens;

   emit Approval(msg.sender, spender, tokens);

   ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);

   return true;

   }

   // ------------------------------------------------------------------------

   // Don't accept ETH

   // ------------------------------------------------------------------------

   function () public payable {

   revert();

   }

   // ------------------------------------------------------------------------

   // Owner can transfer out any accidentally sent ERC20 tokens

   // ------------------------------------------------------------------------

   function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {

   return ERC20Interface(tokenAddress).transfer(owner, tokens);

   }

}

Details

Token: Ballet Token
Ticker: BALLET
Decimals: 18
Contract: 0xb9ADd59BC80F716f17AB09B33f173510A568B666

Exchange

https://etherdelta.com/#0xb9add59bc80f716f17ab09b33f173510a568b666-ETH

Wow! Brilliant! I am happy that I can now buy BALLET on EtherDelta Exchange

EtherDelta is an open-source and decentralized exchange for ETH based tokens. It provides a simple and safe interface to trade ETH based tokens for a very low fee.

On Etherdelta you remain in 100% control of your funds all the time. The private keys that you import there are never sent over the internet, and all transaction signing operations are done locally, stored in the cache of your browser

So the funds you have on Etherdelta can't be censored, seized, hacked like with legacy centralized exchanges. But you should still practice good computer security procedures to ensure the safety of your keys, and avoid phishing websites.

Jezzy of Jensen

Posts

Merits