Created
February 2, 2018 19:56
-
-
Save anonymous/ec35a2ab3e82be27c3862fb2c94ebd5e to your computer and use it in GitHub Desktop.
Created using browser-solidity: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://ethereum.github.io/browser-solidity/#version=soljson-v0.4.19+commit.c4cbbb05.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.18; | |
import "./ERC20Basic.sol"; | |
import "./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.4.18; | |
import "./Ownable.sol"; | |
contract Board is Ownable { | |
mapping(address => bool) public members; | |
mapping(address => bool) public voteBool; // last voting bool | |
mapping(address => uint256) public voted; | |
uint256 public reqETH; | |
uint256 public voteStart; | |
uint256 public voteEnd; | |
uint256 public votes; | |
uint256 public proposalNum; | |
uint256 public totalMember; | |
function Board() public { | |
members[owner] = true; | |
totalMember++; | |
} | |
function addMember(address targetAddress) onlyOwner public { | |
members[targetAddress] = true; | |
totalMember++; | |
} | |
function removeMember(address targetAddress) onlyOwner public { | |
require(members[targetAddress]); | |
delete members[targetAddress]; | |
totalMember--; | |
} | |
// can use % funds | |
function proposal(uint256 _reqETH, uint256 startBlock, uint256 endBlock) onlyOwner public { | |
require(block.number > voteEnd); // owner can start the proposal only if the previous porp gets over | |
reqETH = _reqETH * 1 ether; | |
voteStart = startBlock; | |
voteEnd = endBlock; | |
votes = 0; | |
proposalNum++; | |
} | |
function vote(bool canCollectETH) public { | |
require(members[msg.sender]); | |
require(voted[msg.sender] < proposalNum); | |
voted[msg.sender] = proposalNum; | |
voteBool[msg.sender] = canCollectETH; | |
if (canCollectETH) { | |
votes++; | |
} | |
} | |
} |
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"; | |
/** | |
* @title Burnable Token | |
* @dev Token that can be irreversibly burned (destroyed). | |
*/ | |
contract BurnableToken is BasicToken { | |
event Burn(address indexed burner, uint256 value); | |
/** | |
* @dev Burns a specific amount of tokens. | |
* @param _value The amount of token to be burned. | |
*/ | |
function burn(uint256 _value) public { | |
require(_value <= balances[msg.sender]); | |
// no need to require value <= totalSupply, since that would imply the | |
// sender's balance is greater than the totalSupply, which *should* be an assertion failure | |
address burner = msg.sender; | |
balances[burner] = balances[burner].sub(_value); | |
totalSupply_ = totalSupply_.sub(_value); | |
Burn(burner, _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.4.18; | |
import "./Ownable.sol"; | |
contract KYC is Ownable { | |
mapping(address => bool) public kycStatus; | |
function KYC() public { | |
kycStatus[owner] = true; | |
} | |
function addMember(address targetAddress) onlyOwner public { | |
kycStatus[targetAddress] = true; | |
} | |
function removeMember(address targetAddress) onlyOwner public { | |
delete kycStatus[targetAddress]; | |
} | |
function changeStatus(address targetAddress, bool kycBool) onlyOwner public { | |
kycStatus[targetAddress] = kycBool; | |
} | |
} |
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 "./Ownable.sol"; | |
import "./StandardToken.sol"; | |
import "./KYC.sol"; | |
/** | |
* @title SampleCrowdsaleToken | |
* @dev Very simple ERC20 Token that can be minted. | |
* It is meant to be used in a crowdsale contract. | |
*/ | |
contract MintRedeem is Ownable, StandardToken, KYC { | |
event Mint(address indexed to, uint256 amount); | |
string public constant name = "MoatCoin"; | |
string public constant symbol = "MTCv1"; | |
uint8 public constant decimals = 0; | |
// wei per MTC // 1 ETH = 10000 MTC // 100000000000000 | |
uint256 public mtcRate; | |
uint256 public mintStart; | |
uint256 public mintEnd; | |
uint256 public mintBonus; // in percent | |
bool public pvtMint; | |
uint256 public redeemRate; | |
uint256 public redeemStart; | |
uint256 public redeemEnd; | |
mapping(address => bool) public PvtMintAddress; | |
uint256 public maxSupply; | |
uint256 public ethRaised; | |
uint256 public ethRedeemed; | |
function NetWorth() public returns (uint) { | |
return (ethRaised - ethRedeemed); | |
} | |
function incSupply(uint256 _maxSupply) onlyOwner public { | |
require(_maxSupply >= totalSupply_); | |
maxSupply = _maxSupply; | |
} | |
function addPvtMintAddress(address targetAddress) onlyOwner public { | |
PvtMintAddress[targetAddress] = true; | |
} | |
function publicMint(uint256 startBlock, uint256 endBlock, uint256 _rate, uint256 _bonus, bool mintStatus) onlyOwner public { | |
require(block.number > redeemEnd); | |
require(_bonus < 6); | |
mintStart = startBlock; | |
mintEnd = endBlock; | |
mtcRate = _rate; | |
mintBonus = _bonus; | |
pvtMint = mintStatus; | |
} | |
function startRedeem(uint256 startBlock, uint256 endBlock, uint256 _rate) onlyOwner public { | |
require(block.number > mintEnd); | |
redeemStart = startBlock; | |
redeemEnd = endBlock; | |
redeemRate = _rate; | |
} | |
// function called from MotaFund.sol | |
function mint(address beneficiary) public payable { | |
require(block.number > mintStart && block.number < mintEnd); | |
require(msg.value > 0); | |
require(msg.sender != owner); // the owner can't mint | |
require(maxSupply >= totalSupply_); | |
if (pvtMint) { | |
require(PvtMintAddress[msg.sender]); | |
} | |
uint256 weiVal = getExactWei(msg.value); | |
uint256 MTCToken = calcMTC(weiVal); | |
uint256 teamToken = calcTeamMTC(MTCToken); | |
ethRaised += msg.value; | |
totalSupply_ = totalSupply_.add(MTCToken + teamToken); | |
balances[beneficiary] = balances[beneficiary].add(MTCToken); | |
balances[owner] = balances[owner].add(teamToken); | |
Mint(beneficiary, MTCToken); | |
Transfer(address(0), beneficiary, MTCToken); | |
} | |
function getExactWei(uint256 _wei) public returns (uint256) { | |
return (_wei - (_wei % mtcRate)); | |
} | |
function calcMTC(uint256 _weiVal) public returns (uint256) { | |
uint256 _mtc = (_weiVal / mtcRate); | |
uint256 mulBonus = (_mtc * mintBonus); | |
uint256 divBonus = (mulBonus/100); | |
return (_mtc + divBonus); | |
} | |
function calcTeamMTC(uint256 _mtc) public returns (uint256) { | |
uint256 deductBonus = (_mtc * (5 - mintBonus)); | |
return (deductBonus/100); | |
} | |
function redeemMTC(uint256 _mtc) public { | |
require(block.number > redeemStart && block.number < redeemEnd); | |
require(_mtc > 0 && _mtc <= balances[msg.sender]); | |
require(kycStatus[msg.sender]); | |
uint256 weiVal = _mtc.mul(redeemRate); | |
ethRedeemed += weiVal; | |
totalSupply_ = totalSupply_.sub(_mtc); | |
balances[msg.sender] = balances[msg.sender].sub(_mtc); | |
msg.sender.transfer(weiVal); | |
} | |
} |
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 "./Ownable.sol"; | |
import "./Board.sol"; | |
import "./MintRedeem.sol"; | |
/** | |
* @title SampleCrowdsaleToken | |
* @dev Very simple ERC20 Token that can be minted. | |
* It is meant to be used in a crowdsale contract. | |
*/ | |
contract MoatFund is Ownable, Board, MintRedeem { | |
function () public payable { | |
mint(msg.sender); | |
} | |
function collect() onlyOwner public { | |
require(block.number > voteEnd); | |
require((votes*10) > (totalMember*5)); // votes are greater than totalMember/2 i.e 50%; | |
msg.sender.transfer(reqETH); | |
reqETH = 0; // so the owner can take ETH ether once after voting | |
} | |
} | |
// strata MTC distribute // give up 1% team MTC for +5 ETH / give up 2% team MTC for +10 ETH / give up 2% team MTC for +10 ETH / give up 3% team MTC for +10 ETH / give up 4% team MTC for +20 ETH | |
// special mint for higher and anytime funding and become director (with dynamic discount field on team MTC) | |
// code comments | |
// do pre ICO with big players (you'll become member of the board) | |
//// check | |
// rounding of wei when token minted | |
// check token burning | |
// check redeem | |
// check I get all the mapping address with balances | |
//// change | |
// update website | |
// start kyc | |
//// remember | |
// transfer other ERC20 token stored in the old smart contract to new smart contract. Make sure you create a function in old SC >>> https://ethereum.stackexchange.com/questions/23577/will-contract-selfdestruct-also-return-tokens |
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"; | |
import "./BurnableToken.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, BurnableToken { | |
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; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment