Skip to content

Instantly share code, notes, and snippets.

@Bigomby
Created August 30, 2018 13:13
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
Star You must be signed in to star a gist
Save Bigomby/713195295c0d7dcb4e09533f879e67ad to your computer and use it in GitHub Desktop.
pragma solidity ^0.4.20;
import "./ERC721Basic.sol";
import "./SafeMath.sol";
import "./Ownable.sol";
contract ColmenaToken is ERC721Basic, Ownable {
using SafeMath for uint256;
event accountCreated(address, uint256);
uint256 constant public MIN_VOTES = 3;
struct Token {
address[MIN_VOTES] voters;
}
mapping (uint256 => Token) public tokens;
mapping (address => uint256) internal ownedTokensCount;
mapping (uint256 => address) internal tokenOwner;
mapping (uint256 => address) internal tokenApprovals;
mapping (address => uint256) internal whitelist;
mapping (address => mapping (address => bool)) internal operatorApprovals;
uint256 public blocksBeforeActivation;
constructor(uint256 _blocksBeforeActivation) public {
blocksBeforeActivation = _blocksBeforeActivation;
}
function addNewAccount(address _account) public onlyOwner() {
require(_account != address(0));
whitelist[_account] = block.number;
}
function isWhitelisted(address _account) returns (bool) {
require(whitelist[_account] != 0);
return block.number - whitelist[_account] >= blocksBeforeActivation;
}
function removeAccount(address _account) public onlyOwner() returns (bool) {
require(_account != address(0));
whitelist[_account] = 0;
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from, address _to, uint256 _tokenId) public {
require(isApprovedOrOwner(msg.sender, _tokenId));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public {
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public {
transferFrom(_from, _to, _tokenId);
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) internal view returns (bool) {
address owner = ownerOf(_tokenId);
return (_spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender));
}
function vote(address _to, uint256 _tokenId) public {
require(_to != address(0));
require(isWhitelisted(_to));
uint256 preTokenId = block.hash;
uint256 tokenId = keccak256(preTokenId) % 32768;
while (tokens[tokenId].votes != 0) {
tokenId = keccak256(preTokenId++) % 32768;
}
if (tokens[tokenId].voters >= ) {
}
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment