Skip to content

Instantly share code, notes, and snippets.

/MappedStructsWithIndex.sol

Created February 14, 2018 09:08
Show Gist options
  • Save anonymous/0929c407d5f7df8668287e3079a88edf to your computer and use it in GitHub Desktop.
Save anonymous/0929c407d5f7df8668287e3079a88edf to your computer and use it in GitHub Desktop.
Download ZIP
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=
Raw
arrayWithUniqueId.sol
pragma solidity ^0.4.2;
contract arrayWithUniqueId {
struct EntityStruct {
address entityAddress;
uint entityData;
}
EntityStruct[] public entityStructs;
mapping(address => bool) knownEntity;
function isEntity(address entityAddress) public constant returns(bool isIndeed) {
return knownEntity[entityAddress];
}
function getEntityCount() public constant returns(uint entityCount) {
return entityStructs.length;
}
function newEntity(address entityAddress, uint entityData) public returns(uint rowNumber) {
if(isEntity(entityAddress)) throw;
EntityStruct memory newEntity;
newEntity.entityAddress = entityAddress;
newEntity.entityData = entityData;
knownEntity[entityAddress] = true;
return entityStructs.push(newEntity) - 1;
}
function updateEntity(uint rowNumber, address entityAddress, uint entityData) public returns(bool success) {
if(!isEntity(entityAddress)) throw;
if(entityStructs[rowNumber].entityAddress != entityAddress) throw;
entityStructs[rowNumber].entityData = entityData;
return true;
}
}
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
MappedStructsWithIndex.sol
contract MappedStructsWithIndex {
struct EntityStruct {
uint entityData;
bool isEntity;
}
mapping(address => EntityStruct) public entityStructs;
address[] public entityList;
function isEntity(address entityAddress) public constant returns(bool isIndeed) {
return entityStructs[entityAddress].isEntity;
}
function getEntityCount() public constant returns(uint entityCount) {
return entityList.length;
}
function newEntity(address entityAddress, uint entityData) public returns(uint rowNumber) {
if(isEntity(entityAddress)) throw;
entityStructs[entityAddress].entityData = entityData;
entityStructs[entityAddress].isEntity = true;
return entityList.push(entityAddress) - 1;
}
function updateEntity(address entityAddress, uint entityData) public returns(bool success) {
if(!isEntity(entityAddress)) throw;
entityStructs[entityAddress].entityData = entityData;
return true;
}
}
Raw
mappingWithStruct.sol
pragma solidity ^0.4.2;
contract mappingWithStruct {
struct EntityStruct {
uint entityData;
bool isEntity;
}
mapping (address => EntityStruct) public entityStructs;
function isEntity(address entityAddress) public constant returns(bool isIndeed) {
return entityStructs[entityAddress].isEntity;
}
function newEntity(address entityAddress, uint entityData) public returns(bool success) {
if(isEntity(entityAddress)) throw;
entityStructs[entityAddress].entityData = entityData;
entityStructs[entityAddress].isEntity = true;
return true;
}
function deleteEntity(address entityAddress) public returns(bool success) {
if(!isEntity(entityAddress)) throw;
entityStructs[entityAddress].isEntity = false;
return true;
}
function updateEntity(address entityAddress, uint entityData) public returns(bool success) {
if(!isEntity(entityAddress)) throw;
entityStructs[entityAddress].entityData = entityData;
return true;
}
function getEntityDetails(address entityAddress) public constant returns(address,uint) {
if(!isEntity(entityAddress)) throw;
return (entityAddress,entityStructs[entityAddress].entityData);
}
}
Raw
retail.sol
pragma solidity ^0.4.11;
contract samplestruct {
address public admin;
uint count=0;
// a constructor to set the admin i.e the person who deploys the contract
function samplestruct() {
admin= msg.sender;
}
// A struct of Item
struct itemstruct {
string itemname;
address itemowner;
uint itemprice;
uint itemid;
bool isSold;
}
itemstruct[] public items; // an array of structs
function addItem(string itemname,uint itemprice) returns (string){
if(msg.sender!=admin) return ("you are not allowed to add item");
count = count+1;
items.push(itemstruct({itemname:itemname, itemowner:msg.sender,itemprice:itemprice,itemid:count,isSold:false}));
return ("successfully added item");
}
// A function to get all the bid details
function getItem(uint i) constant returns(string,address,uint,uint,bool){
return (items[i].itemname,items[i].itemowner,items[i].itemprice,items[i].itemid,items[i].isSold);
}
function isSold(uint itemId) constant returns (bool){
return items[itemId].isSold;
}
// a function to buy an Item
function buyItem(uint i) public constant returns (string,bool) {
if(items[i].isSold ==true) return("the Item is already sold",false);else {
require(i >= 0 && i <= count);
// items[i].itemowner = msg.sender;
// items[i].isSold = true;
itemstruct memory item = items[i];
item.isSold=true;
items[i]=item;
return ("Item purchased",items[i].isSold);
}
}
}
Raw
test.sol
pragma solidity ^0.4.2;
contract test {
address public admin;
uint count=0;
// a constructor to set the admin i.e the person who deploys the contract
function test() {
admin= msg.sender;
}
// A struct of Item
struct itemstruct {
string itemname;
address itemowner;
uint itemprice;
uint itemid;
bool isSold;
}
mapping(uint => itemstruct) public itemStructs; // mapping the itemId with itemStruct
uint[] public itemList; //list of ItemId's
function addItem(string itemname,uint itemprice) returns (string){
if(msg.sender!=admin) return ("you are not allowed to add item");
count = count+1;
items.push(itemstruct({itemname:itemname, itemowner:msg.sender,itemprice:itemprice,itemid:count,isSold:false}));
return ("successfully added item");
}
// A function to get all the bid details
function getItem(uint i) constant returns(string,address,uint,uint,bool){
return (items[i].itemname,items[i].itemowner,items[i].itemprice,items[i].itemid,items[i].isSold);
}
function isSold(uint itemId) constant returns (bool){
return items[itemId].isSold;
}
// a function to buy an Item
function buyItem(uint i) public constant returns (string) {
if(items[i].isSold ==true) return("the Item is already sold");else {
require(i >= 0 && i <= count);
/*items[i].itemowner = msg.sender;
items[i].isSold = true;*/
items.push(itemstruct({itemname:items[i].itemname,
itemowner:msg.sender,
itemprice:items[i].itemprice,
itemid:items[i].itemid,
isSold:true}));
return ("Item purchased");
}
}
}
Raw
Token.sol
pragma solidity ^0.4.4;
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
//if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
//name this contract whatever you'd like
contract ERC20Token is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
string public symbol; //An identifier: eg SBX
string public version = 'H1.0'; //human 0.1 standard. Just an arbitrary versioning scheme.
//make sure this function name matches the contract name above. So if you're token is called TutorialToken, make sure the //contract name above is also TutorialToken instead of ERC20Token
function ERC20Token() {
balances[msg.sender] = 99999; // Give the creator all initial tokens (100000 for example)
totalSupply = 99999; // Update total supply (100000 for example)
name = "ToniToken"; // Set the name for display purposes
decimals = 0; // Amount of decimals for display purposes
symbol = ":)"; // Set the symbol for display purposes
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
//it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
}
Raw
Tx.sol
pragma solidity ^0.4.2;
contract Tx {
uint public balance;
function checkandRetun() payable{
if(msg.value>10 ether){
balance += msg.value;
}else{
msg.sender.transfer(msg.value-1);
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment