Skip to content

Instantly share code, notes, and snippets.

@annu18priya

annu18priya/TestToken.sol

Created August 14, 2018 11:15
Show Gist options
  • Save annu18priya/829fa708040b4f95e0fe37245e5aa57b to your computer and use it in GitHub Desktop.
Save annu18priya/829fa708040b4f95e0fe37245e5aa57b to your computer and use it in GitHub Desktop.
Download ZIP
Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.4.24+commit.e67f0147.js&optimize=false&gist=
Raw
ballot.sol
pragma solidity ^0.4.0;
contract Ballot {
struct Voter {
uint weight;
bool voted;
uint8 vote;
address delegate;
}
struct Proposal {
uint voteCount;
}
address chairperson;
mapping(address => Voter) voters;
Proposal[] proposals;
/// Create a new ballot with $(_numProposals) different proposals.
function Ballot(uint8 _numProposals) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
proposals.length = _numProposals;
}
/// Give $(toVoter) the right to vote on this ballot.
/// May only be called by $(chairperson).
function giveRightToVote(address toVoter) public {
if (msg.sender != chairperson || voters[toVoter].voted) return;
voters[toVoter].weight = 1;
}
/// Delegate your vote to the voter $(to).
function delegate(address to) public {
Voter storage sender = voters[msg.sender]; // assigns reference
if (sender.voted) return;
while (voters[to].delegate != address(0) && voters[to].delegate != msg.sender)
to = voters[to].delegate;
if (to == msg.sender) return;
sender.voted = true;
sender.delegate = to;
Voter storage delegateTo = voters[to];
if (delegateTo.voted)
proposals[delegateTo.vote].voteCount += sender.weight;
else
delegateTo.weight += sender.weight;
}
/// Give a single vote to proposal $(toProposal).
function vote(uint8 toProposal) public {
Voter storage sender = voters[msg.sender];
if (sender.voted || toProposal >= proposals.length) return;
sender.voted = true;
sender.vote = toProposal;
proposals[toProposal].voteCount += sender.weight;
}
function winningProposal() public constant returns (uint8 _winningProposal) {
uint256 winningVoteCount = 0;
for (uint8 prop = 0; prop < proposals.length; prop++)
if (proposals[prop].voteCount > winningVoteCount) {
winningVoteCount = proposals[prop].voteCount;
_winningProposal = prop;
}
}
}
Raw
ballot_test.sol
pragma solidity ^0.4.7;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./ballot.sol";
contract test3 {
Ballot ballotToTest;
function beforeAll () {
ballotToTest = new Ballot(2);
}
function checkWinningProposal () public {
ballotToTest.vote(1);
Assert.equal(ballotToTest.winningProposal(), uint(1), "1 should be the winning proposal");
}
function checkWinninProposalWithReturnValue () public constant returns (bool) {
return ballotToTest.winningProposal() == 1;
}
}
Raw
TestToken.sol
pragma solidity ^0.4.0;
// https://medium.com/coinmonks/create-your-own-cryptocurrency-in-ethereum-blockchain-40865db8a29f
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferableOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecepient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TokenERC20 {
// Public variables of Token
string public name;
string public symbol;
uint8 public decimal = 18; // 18 decimal values is strongly suggested. Avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceof;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public events on blockchain that will notify clients
event Transfer(address indexed from, address indexed to , uint256 value);
// This generates a public events on blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notified client about the amount burns
// Burn methods is used when we want to destroy unsold tokens
event Burn(address indexed From, uint256 value);
/**
* constructor function
*
* Initializes contract with initial supply tokens with creator of contract
*/
constructor(uint256 initialSupply, string tokenName, string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimal); // update total supply with decimal amount
balanceof[msg.sender] = totalSupply; // Give the creator all initial token
name = tokenName; // the name for display purpose
symbol = tokenSymbol; // the symbol for display purpose
}
/**
* Internal transfer, only can be handled by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceof[_from] >= _value);
// Check for overflow
require(balanceof[_to] + _value > balanceof[_to]);
// Save this for assestion in future
uint previousBalances = balanceof[_from] + balanceof[_to];
// Subtract from the sender
balanceof[_from] -= _value;
// Add the same to the recipient
balanceof[_to] += _value;
emit Transfer(_from, _to, _value);
// Assert are used to use static analysis to find bugs in your code. They should never fail.
assert(balanceof[_to] + balanceof[_from] == previousBalances);
}
/**
* Token Transfer
*
* Send '_value' tokens to '_to' in behalf of '_from'
*
* @param _to The address of the receiver
* @param _value the amount to send
*
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
/**
* Token Transfer 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 receiver
* @param _value the amount to send
*
*/
function transferFrom(address _to, address _from ,uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // check allowance
_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 (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* 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, bytes _extraData) public returns (bool success) {
tokenRecepient spender = tokenRecepient(_spender);
if(approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
*
* Remove '_value' token from the system irreversibly
*
* @param _value the amount to burn
*
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceof[msg.sender] >= _value); // Check if sender has enough
balanceof[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates total supply
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 (bool success) {
require(balanceof[_from] >= _value); // Check if targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceof[_from] -= _value; // Subtract from the targeted balanceof
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract Sikka is owned, TokenERC20 {
uint256 public sellPrice;
uint256 public buyPrice;
mapping(address => bool) public frozenAccount;
/* This generates a public event in blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
/* Initialize contract with initial supply tokens to the creator of the contract */
constructor(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) 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 != 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, uint256 mintedAmount) onlyOwner public {
balanceof[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(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(address target, bool freeze) 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(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
/// @notice Buy tokens from contract by sending ether
function buy() payable public {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
address myAddress = this;
require(myAddress.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, 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
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment