Created
January 2, 2019 08:13
-
-
Save suattop/16be4de2d2481675a950e910ac801083 to your computer and use it in GitHub Desktop.
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.5.2+commit.1df8f40c.js&optimize=false&gist=
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
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; | |
} | |
} | |
} |
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
pragma solidity ^0.4.13; | |
import '../node_modules/zeppelin-solidity/contracts/token/ERC20/MintableToken.sol'; | |
contract BaniCoin is MintableToken { | |
string public name = "Banigo COIN"; | |
string public symbol = "BG$"; | |
uint8 public decimals = 18; | |
} | |
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
pragma solidity ^0.4.13; | |
import '../node_modules/zeppelin-solidity/contracts/crowdsale/Crowdsale.sol'; | |
import './BaniCoin.sol'; | |
contract BaniCoinCrowdsale is Crowdsale { | |
function BaniCoinCrowdsale(uint256 _rate, address _wallet) | |
Crowdsale(_rate, _wallet) public { | |
} | |
// creates the token to be sold. | |
// override this method to have crowdsale of a specific MintableToken token. | |
function createTokenContract() internal returns (MintableToken) { | |
return new BaniCoin(); | |
} | |
} | |
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
pragma solidity ^0.4.18; | |
import "./ERC20Basic.sol"; | |
import "../../math/SafeMath.sol"; | |
/** | |
* @title Basic token | |
* @dev Basic version of StandardToken, with no allowances. | |
*/ | |
contract BasicToken is ERC20Basic { | |
using SafeMath for uint256; | |
mapping(address => uint256) balances; | |
uint256 totalSupply_; | |
/** | |
* @dev total number of tokens in existence | |
*/ | |
function totalSupply() public view returns (uint256) { | |
return totalSupply_; | |
} | |
/** | |
* @dev transfer token for a specified address | |
* @param _to The address to transfer to. | |
* @param _value The amount to be transferred. | |
*/ | |
function transfer(address _to, uint256 _value) public returns (bool) { | |
require(_to != address(0)); | |
require(_value <= balances[msg.sender]); | |
// SafeMath.sub will throw if there is not enough balance. | |
balances[msg.sender] = balances[msg.sender].sub(_value); | |
balances[_to] = balances[_to].add(_value); | |
Transfer(msg.sender, _to, _value); | |
return true; | |
} | |
/** | |
* @dev Gets the balance of the specified address. | |
* @param _owner The address to query the the balance of. | |
* @return An uint256 representing the amount owned by the passed address. | |
*/ | |
function balanceOf(address _owner) public view returns (uint256 balance) { | |
return balances[_owner]; | |
} | |
} |
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
pragma solidity ^0.5.1; | |
contract Owned { | |
address owner; | |
constructor() public { | |
owner = msg.sender; | |
} | |
modifier onlyOwner { | |
require(msg.sender == owner); | |
_; | |
} | |
} | |
contract Certificate is Owned{ | |
struct Holder { | |
uint level; | |
bytes16 name; | |
} | |
mapping (address => Holder) holders; | |
address[] public holderAccts; | |
modifier checkLevel(uint _level) { | |
require( | |
_level <= 3, | |
"You input the wrong level." | |
); | |
_; | |
} | |
event holderInfo( | |
bytes16 name, | |
uint level | |
); | |
function setHolder(address _address, bytes16 _name, uint _level) onlyOwner checkLevel(_level) public { | |
Holder memory holder = holders[_address]; | |
holder.level = _level; | |
holder.name = _name; | |
holderAccts.push(_address); | |
emit holderInfo(_name, _level); | |
} | |
function getHolders() view public returns (address[] memory) { | |
return holderAccts; | |
} | |
function getHolder(address hAddress) view public returns (uint, bytes16) { | |
return (holders[hAddress].level, holders[hAddress].name); | |
} | |
function countHolders() view public returns (uint) { | |
return holderAccts.length; | |
} | |
} |
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
pragma solidity ^0.5.1; | |
contract Owned { | |
address owner; | |
constructor () public { | |
owner = msg.sender; | |
} | |
modifier onlyOwner { | |
require(msg.sender == owner); | |
_; | |
} | |
} | |
contract Courses is Owned { | |
struct Instructor { | |
uint age; | |
bytes16 fName; | |
bytes16 lName; | |
} | |
mapping (address => Instructor) instructors; | |
address[] public instructorsAccts; | |
event instructorInfo( | |
bytes16 fName, | |
bytes16 lName, | |
uint age | |
); | |
function setInstructor(address _address, uint _age, bytes16 _fName, bytes16 _lName) onlyOwner public { | |
Instructor memory instructor = instructors[_address]; | |
instructor.age = _age; | |
instructor.fName = _fName; | |
instructor.lName = _lName; | |
instructorsAccts.push(_address) -1; | |
emit instructorInfo(_fName, _lName, _age); | |
} | |
function getInstructors() view public returns (address[] memory) { | |
return instructorsAccts; | |
} | |
function getInstructor(address ins) view public returns (uint, bytes16, bytes16) { | |
return (instructors[ins].age, instructors[ins].fName, instructors[ins].lName); | |
} | |
function countInstructors() view public returns (uint) { | |
return instructorsAccts.length; | |
} | |
} |
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
pragma solidity ^0.5.1; | |
contract Coursetro { | |
string fName; | |
uint age; | |
address owner; | |
constructor () public { | |
owner = msg.sender; | |
} | |
modifier onlyOwner { | |
require(msg.sender == owner); | |
_; | |
} | |
event Instructor( | |
string name, | |
uint age | |
); | |
function setInstructor(string memory _fName, uint _age) onlyOwner public { | |
fName = _fName; | |
age = _age; | |
emit Instructor(_fName, _age); | |
} | |
function getInstructor() public view returns (string memory, uint) { | |
return (fName, age); | |
} | |
} |
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
pragma solidity ^0.4.18; | |
import "../math/SafeMath.sol"; | |
import "../token/ERC20/MintableToken.sol"; | |
/** | |
* @title Crowdsale | |
* @dev Crowdsale is a base contract for managing a token crowdsale, | |
* allowing investors to purchase tokens with ether. This contract implements | |
* such functionality in its most fundamental form and can be extended to provide additional | |
* functionality and/or custom behavior. | |
* The external interface represents the basic interface for purchasing tokens, and conform | |
* the base architecture for crowdsales. They are *not* intended to be modified / overriden. | |
* The internal interface conforms the extensible and modifiable surface of crowdsales. Override | |
* the methods to add functionality. Consider using 'super' where appropiate to concatenate | |
* behavior. | |
*/ | |
contract Crowdsale { | |
using SafeMath for uint256; | |
// The token being sold | |
MintableToken public token; | |
// Address where funds are collected | |
address public wallet; | |
// How many token units a buyer gets per wei | |
uint256 public rate; | |
// Amount of wei raised | |
uint256 public weiRaised; | |
/** | |
* Event for token purchase logging | |
* @param purchaser who paid for the tokens | |
* @param beneficiary who got the tokens | |
* @param value weis paid for purchase | |
* @param amount amount of tokens purchased | |
*/ | |
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); | |
/** | |
* @param _rate Number of token units a buyer gets per wei | |
* @param _wallet Address where collected funds will be forwarded to | |
*/ | |
function Crowdsale(uint256 _rate, address _wallet) public { | |
require(_rate > 0); | |
require(_wallet != address(0)); | |
rate = _rate; | |
wallet = _wallet; | |
token = createTokenContract(); | |
} | |
function createTokenContract() internal returns (MintableToken) { | |
return new MintableToken(); | |
} | |
// ----------------------------------------- | |
// Crowdsale external interface | |
// ----------------------------------------- | |
/** | |
* @dev fallback function ***DO NOT OVERRIDE*** | |
*/ | |
function () external payable { | |
buyTokens(msg.sender); | |
} | |
/** | |
* @dev low level token purchase ***DO NOT OVERRIDE*** | |
* @param _beneficiary Address performing the token purchase | |
*/ | |
function buyTokens(address _beneficiary) public payable { | |
uint256 weiAmount = msg.value; | |
_preValidatePurchase(_beneficiary, weiAmount); | |
// calculate token amount to be created | |
uint256 tokens = _getTokenAmount(weiAmount); | |
// update state | |
weiRaised = weiRaised.add(weiAmount); | |
_processPurchase(_beneficiary, tokens); | |
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens); | |
_updatePurchasingState(_beneficiary, weiAmount); | |
_forwardFunds(); | |
_postValidatePurchase(_beneficiary, weiAmount); | |
} | |
// ----------------------------------------- | |
// Internal interface (extensible) | |
// ----------------------------------------- | |
/** | |
* @dev Validation of an incoming purchase. Use require statemens to revert state when conditions are not met. Use super to concatenate validations. | |
* @param _beneficiary Address performing the token purchase | |
* @param _weiAmount Value in wei involved in the purchase | |
*/ | |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal { | |
require(_beneficiary != address(0)); | |
require(_weiAmount != 0); | |
} | |
/** | |
* @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid conditions are not met. | |
* @param _beneficiary Address performing the token purchase | |
* @param _weiAmount Value in wei involved in the purchase | |
*/ | |
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal { | |
// optional override | |
} | |
/** | |
* @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends its tokens. | |
* @param _beneficiary Address performing the token purchase | |
* @param _tokenAmount Number of tokens to be emitted | |
*/ | |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal { | |
//token.transfer(_beneficiary, _tokenAmount); | |
token.mint(_beneficiary, _tokenAmount); | |
} | |
/** | |
* @dev Executed when a purchase has been validated and is ready to be executed. Not necessarily emits/sends tokens. | |
* @param _beneficiary Address receiving the tokens | |
* @param _tokenAmount Number of tokens to be purchased | |
*/ | |
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal { | |
_deliverTokens(_beneficiary, _tokenAmount); | |
} | |
/** | |
* @dev Override for extensions that require an internal state to check for validity (current user contributions, etc.) | |
* @param _beneficiary Address receiving the tokens | |
* @param _weiAmount Value in wei involved in the purchase | |
*/ | |
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal { | |
// optional override | |
} | |
/** | |
* @dev Override to extend the way in which ether is converted to tokens. | |
* @param _weiAmount Value in wei to be converted into tokens | |
* @return Number of tokens that can be purchased with the specified _weiAmount | |
*/ | |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { | |
return _weiAmount.mul(rate); | |
} | |
/** | |
* @dev Determines how ETH is stored/forwarded on purchases. | |
*/ | |
function _forwardFunds() internal { | |
wallet.transfer(msg.value); | |
} | |
} |
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
pragma solidity ^0.4.18; | |
import "./ERC20Basic.sol"; | |
/** | |
* @title ERC20 interface | |
* @dev see https://github.com/ethereum/EIPs/issues/20 | |
*/ | |
contract ERC20 is ERC20Basic { | |
function allowance(address owner, address spender) public view returns (uint256); | |
function transferFrom(address from, address to, uint256 value) public returns (bool); | |
function approve(address spender, uint256 value) public returns (bool); | |
event Approval(address indexed owner, address indexed spender, uint256 value); | |
} |
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
pragma solidity ^0.4.18; | |
/** | |
* @title ERC20Basic | |
* @dev Simpler version of ERC20 interface | |
* @dev see https://github.com/ethereum/EIPs/issues/179 | |
*/ | |
contract ERC20Basic { | |
function totalSupply() public view returns (uint256); | |
function balanceOf(address who) public view returns (uint256); | |
function transfer(address to, uint256 value) public returns (bool); | |
event Transfer(address indexed from, address indexed to, uint256 value); | |
} |
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
pragma solidity ^0.5.1; | |
// create contract named Hashcademy | |
contract Hashcademy { | |
string public name; | |
uint public level; | |
address owner; | |
constructor() public { // Add this constructor | |
owner = msg.sender; | |
} | |
event Certificate( | |
string name, | |
uint level | |
); | |
modifier checkLevel(uint _level) { | |
require( | |
_level <= 3, | |
"You input the wrong level." | |
); | |
_; | |
} | |
modifier onlyOwner { | |
require( | |
msg.sender == owner, | |
"You must be the owner." | |
); | |
_; | |
} | |
function setCertificate(string memory _name, uint _level) onlyOwner checkLevel(_level) public { | |
name = _name; | |
level = _level; | |
emit Certificate(_name, _level); | |
} | |
function getCertificate() public view returns (string memory, uint) { | |
return (name, level); | |
} | |
} |
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
pragma solidity ^0.4.18; | |
/** | |
* @title Ownable | |
* @dev The Ownable contract has an owner address, and provides basic authorization control | |
* functions, this simplifies the implementation of "user permissions". | |
*/ | |
contract Ownable { | |
address public owner; | |
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); | |
/** | |
* @dev The Ownable constructor sets the original `owner` of the contract to the sender | |
* account. | |
*/ | |
function Ownable() public { | |
owner = msg.sender; | |
} | |
/** | |
* @dev Throws if called by any account other than the owner. | |
*/ | |
modifier onlyOwner() { | |
require(msg.sender == owner); | |
_; | |
} | |
/** | |
* @dev Allows the current owner to transfer control of the contract to a newOwner. | |
* @param newOwner The address to transfer ownership to. | |
*/ | |
function transferOwnership(address newOwner) public onlyOwner { | |
require(newOwner != address(0)); | |
OwnershipTransferred(owner, newOwner); | |
owner = newOwner; | |
} | |
} |
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
pragma solidity ^0.4.18; | |
/** | |
* @title SafeMath | |
* @dev Math operations with safety checks that throw on error | |
*/ | |
library SafeMath { | |
/** | |
* @dev Multiplies two numbers, throws on overflow. | |
*/ | |
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; | |
} | |
/** | |
* @dev Integer division of two numbers, truncating the quotient. | |
*/ | |
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; | |
} | |
/** | |
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). | |
*/ | |
function sub(uint256 a, uint256 b) internal pure returns (uint256) { | |
assert(b <= a); | |
return a - b; | |
} | |
/** | |
* @dev Adds two numbers, throws on overflow. | |
*/ | |
function add(uint256 a, uint256 b) internal pure returns (uint256) { | |
uint256 c = a + b; | |
assert(c >= a); | |
return c; | |
} | |
} |
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
pragma solidity ^0.4.18; | |
import "./BasicToken.sol"; | |
import "./ERC20.sol"; | |
/** | |
* @title Standard ERC20 token | |
* | |
* @dev Implementation of the basic standard token. | |
* @dev https://github.com/ethereum/EIPs/issues/20 | |
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol | |
*/ | |
contract StandardToken is ERC20, BasicToken { | |
mapping (address => mapping (address => uint256)) internal allowed; | |
/** | |
* @dev Transfer tokens from one address to another | |
* @param _from address The address which you want to send tokens from | |
* @param _to address The address which you want to transfer to | |
* @param _value uint256 the amount of tokens to be transferred | |
*/ | |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { | |
require(_to != address(0)); | |
require(_value <= balances[_from]); | |
require(_value <= allowed[_from][msg.sender]); | |
balances[_from] = balances[_from].sub(_value); | |
balances[_to] = balances[_to].add(_value); | |
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); | |
Transfer(_from, _to, _value); | |
return true; | |
} | |
/** | |
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. | |
* | |
* Beware that changing an allowance with this method brings the risk that someone may use both the old | |
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this | |
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: | |
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 | |
* @param _spender The address which will spend the funds. | |
* @param _value The amount of tokens to be spent. | |
*/ | |
function approve(address _spender, uint256 _value) public returns (bool) { | |
allowed[msg.sender][_spender] = _value; | |
Approval(msg.sender, _spender, _value); | |
return true; | |
} | |
/** | |
* @dev Function to check the amount of tokens that an owner allowed to a spender. | |
* @param _owner address The address which owns the funds. | |
* @param _spender address The address which will spend the funds. | |
* @return A uint256 specifying the amount of tokens still available for the spender. | |
*/ | |
function allowance(address _owner, address _spender) public view returns (uint256) { | |
return allowed[_owner][_spender]; | |
} | |
/** | |
* @dev Increase the amount of tokens that an owner allowed to a spender. | |
* | |
* approve should be called when allowed[_spender] == 0. To increment | |
* allowed value is better to use this function to avoid 2 calls (and wait until | |
* the first transaction is mined) | |
* From MonolithDAO Token.sol | |
* @param _spender The address which will spend the funds. | |
* @param _addedValue The amount of tokens to increase the allowance by. | |
*/ | |
function increaseApproval(address _spender, uint _addedValue) public returns (bool) { | |
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); | |
Approval(msg.sender, _spender, allowed[msg.sender][_spender]); | |
return true; | |
} | |
/** | |
* @dev Decrease the amount of tokens that an owner allowed to a spender. | |
* | |
* approve should be called when allowed[_spender] == 0. To decrement | |
* allowed value is better to use this function to avoid 2 calls (and wait until | |
* the first transaction is mined) | |
* From MonolithDAO Token.sol | |
* @param _spender The address which will spend the funds. | |
* @param _subtractedValue The amount of tokens to decrease the allowance by. | |
*/ | |
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { | |
uint oldValue = allowed[msg.sender][_spender]; | |
if (_subtractedValue > oldValue) { | |
allowed[msg.sender][_spender] = 0; | |
} else { | |
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); | |
} | |
Approval(msg.sender, _spender, allowed[msg.sender][_spender]); | |
return true; | |
} | |
} |
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
pragma solidity ^0.5.1; | |
// create contract named Hashcademy | |
contract Hashcademy { | |
string name = 'Eric'; | |
uint level = 3; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment