Skip to content

Instantly share code, notes, and snippets.

@Rub3nC

Rub3nC/Array.sol

Created March 22, 2019 18:37
Show Gist options
  • Save Rub3nC/1ac8162e106e82a053d5da72ee17bca4 to your computer and use it in GitHub Desktop.
Save Rub3nC/1ac8162e106e82a053d5da72ee17bca4 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.5.6+commit.b259423e.js&optimize=false&gist=
Raw
Array.sol
pragma solidity >=0.4.22 <0.7.0;
contract myArray {
function getArraySum(uint[] memory _array) public pure returns (uint sum_) {
sum_ = 0;
for (uint i = 0; i < _array.length; i++) {
sum_ += _array[i];
}
}
function getArrayMultipliedByScalar(uint[] memory _array, uint scalar) public pure returns (uint[] memory outputArray) {
outputArray = new uint[](_array.length);
for (uint i = 0; i < _array.length; i++) {
outputArray[i] = _array[i] * scalar;
}
}
function getFixedArrayMultipliedByScalar(uint[3] memory _array, uint scalar) public pure returns (uint[] memory outputArray) {
assert(_array.length == 3);
outputArray = new uint[](_array.length);
for (uint i = 0; i < _array.length; i++) {
outputArray[i] = _array[i] * scalar;
}
}
}
Raw
Ballot.sol
pragma solidity >=0.4.22 <0.7.0;
/// @title Voting with delegation.
contract Ballot {
// This declares a new complex type which will
// be used for variables later.
// It will represent a single voter.
struct Voter {
uint weight; // weight is accumulated by delegation
bool voted; // if true, that person already voted
address delegate; // person delegated to
uint vote; // index of the voted proposal
}
// This is a type for a single proposal.
struct Proposal {
bytes32 name; // short name (up to 32 bytes)
uint voteCount; // number of accumulated votes
}
address public chairperson;
// This declares a state variable that
// stores a `Voter` struct for each possible address.
mapping(address => Voter) public voters;
// A dynamically-sized array of `Proposal` structs.
Proposal[] public proposals;
/// Create a new ballot to choose one of `proposalNames`.
constructor(bytes32[] memory proposalNames) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
// For each of the provided proposal names,
// create a new proposal object and add it
// to the end of the array.
for (uint i = 0; i < proposalNames.length; i++) {
// `Proposal({...})` creates a temporary
// Proposal object and `proposals.push(...)`
// appends it to the end of `proposals`.
proposals.push(Proposal({
name: proposalNames[i],
voteCount: 0
}));
}
}
// Give `voter` the right to vote on this ballot.
// May only be called by `chairperson`.
function giveRightToVote(address voter) public {
// If the first argument of `require` evaluates
// to `false`, execution terminates and all
// changes to the state and to Ether balances
// are reverted.
// This used to consume all gas in old EVM versions, but
// not anymore.
// It is often a good idea to use `require` to check if
// functions are called correctly.
// As a second argument, you can also provide an
// explanation about what went wrong.
require(
msg.sender == chairperson,
"Only chairperson can give right to vote."
);
require(
!voters[voter].voted,
"The voter already voted."
);
require(voters[voter].weight == 0);
voters[voter].weight = 1;
}
/// Delegate your vote to the voter `to`.
function delegate(address to) public {
// assigns reference
Voter storage sender = voters[msg.sender];
require(!sender.voted, "You already voted.");
require(to != msg.sender, "Self-delegation is disallowed.");
// Forward the delegation as long as
// `to` also delegated.
// In general, such loops are very dangerous,
// because if they run too long, they might
// need more gas than is available in a block.
// In this case, the delegation will not be executed,
// but in other situations, such loops might
// cause a contract to get "stuck" completely.
while (voters[to].delegate != address(0)) {
to = voters[to].delegate;
// We found a loop in the delegation, not allowed.
require(to != msg.sender, "Found loop in delegation.");
}
// Since `sender` is a reference, this
// modifies `voters[msg.sender].voted`
sender.voted = true;
sender.delegate = to;
Voter storage delegate_ = voters[to];
if (delegate_.voted) {
// If the delegate already voted,
// directly add to the number of votes
proposals[delegate_.vote].voteCount += sender.weight;
} else {
// If the delegate did not vote yet,
// add to her weight.
delegate_.weight += sender.weight;
}
}
/// Give your vote (including votes delegated to you)
/// to proposal `proposals[proposal].name`.
function vote(uint proposal) public {
Voter storage sender = voters[msg.sender];
require(sender.weight != 0, "Has no right to vote");
require(!sender.voted, "Already voted.");
sender.voted = true;
sender.vote = proposal;
// If `proposal` is out of the range of the array,
// this will throw automatically and revert all
// changes.
proposals[proposal].voteCount += sender.weight;
}
/// @dev Computes the winning proposal taking all
/// previous votes into account.
function winningProposal() public view
returns (uint winningProposal_)
{
uint winningVoteCount = 0;
for (uint p = 0; p < proposals.length; p++) {
if (proposals[p].voteCount > winningVoteCount) {
winningVoteCount = proposals[p].voteCount;
winningProposal_ = p;
}
}
}
// Calls winningProposal() function to get the index
// of the winner contained in the proposals array and then
// returns the name of the winner
function winnerName() public view
returns (bytes32 winnerName_)
{
winnerName_ = proposals[winningProposal()].name;
}
}
Raw
Coin.sol
pragma solidity >=0.5.0 <0.7.0;
contract Coin {
// The keyword "public" makes those variables
// easily readable from outside.
address public minter;
mapping (address => uint) public balances;
// Events allow light clients to react to
// changes efficiently.
event Sent(address from, address to, uint amount);
// This is the constructor whose code is
// run only when the contract is created.
constructor() public {
minter = msg.sender;
}
function mint(address receiver, uint amount) public {
require(msg.sender == minter);
require(amount < 1e60);
balances[receiver] += amount;
}
function send(address receiver, uint amount) public {
require(amount <= balances[msg.sender], "Insufficient balance.");
balances[msg.sender] -= amount;
balances[receiver] += amount;
emit Sent(msg.sender, receiver, amount);
}
}
Raw
Storage.sol
pragma solidity >=0.4.0 <0.7.0;
contract SimpleStorage {
uint storedData;
uint myNumber;
function setNumber(uint x) public {
myNumber = x;
}
function set(uint y) public {
storedData = y;
}
function get() public view returns (uint) {
return storedData;
}
function getNumber() public view returns (uint) {
return myNumber;
}
}
Raw
Strings.sol
pragma solidity >=0.4.22 <0.7.0;
view returns (string memory) {
return store;
}
function setStore(string memory _value) public {
store = _value;
}
function createString() public pure returns (string memory) {
string memory newString = new string(3);
bytes memory byteString = bytes(newString);
byteString[0] = "A";
byteString[1] = "b";
byteString[2] = "X";
return string(byteString);
}
function getStringLength(string memory _s) public pure returns (uint) {
bytes memory bs = bytes(_s);
return bs.length;
}
}
Raw
uBloggerPost.sol
pragma solidity >=0.4.22 <0.7.0;
import "./uBloggerRegistry.sol";
contract uBloggerPost {
address uBloggerRegistryLocation;
address owner;
struct Post {
uint timestamp;
string postData;
}
mapping (uint => Post) public posts;
uint postNumber;
constructor () public {
owner = msg.sender;
uBloggerRegistryLocation = 0x5c22A3e8648A43d5731Da3ED79f5e3E9ba37bd93;
}
function createPost(string memory _post) public returns (int result, uint _postID){
uBloggerRegistry registry = uBloggerRegistry(uBloggerRegistryLocation);
string memory _accountName = registry.getAccountName(msg.sender);
if (bytes(_accountName).length == 0){
result = -1;
} else if (owner != msg.sender){
result = -2;
} else if (bytes(_post).length >= 160) {
result = -3;
} else {
posts[postNumber].timestamp = now;
posts[postNumber].postData = _post;
postNumber++;
result = 0; // Success
_postID = postNumber - 1;
}
}
function getPost(uint _postID) public view returns (uint _timestamp, string memory _postData) {
_timestamp = posts[_postID].timestamp;
_postData = posts[_postID].postData;
}
function getTotalPosts() public view returns (uint _postNumber) {
_postNumber = postNumber;
}
/*function verifyOwner() public view returns(int result, string memory _accountName){
uBloggerRegistry registry = uBloggerRegistry(uBloggerRegistryLocation);
_accountName = registry.getAccountName(msg.sender);
if (bytes(_accountName).length > 0) {
result = 0;
} else {
result = -1;
}
}*/
}
Raw
uBloggerRegistry.sol
pragma solidity >=0.4.22 <0.7.0;
contract uBloggerRegistry {
mapping(address => string) public address2Name;
mapping(string => address) public name2Address;
int256 numOfAccounts;
address admin;
bool registrationDisabled;
constructor () public {
numOfAccounts = 0;
admin = msg.sender;
registrationDisabled = false;
}
function registerAccount(string memory accountName) public returns (int result) {
if (registrationDisabled == true) {
// Registration is disabled.
result = -1;
}else if ( bytes(accountName).length == 0 || bytes(accountName).length > 10) {
// length of the accountName is invalid
result = -2;
} else if (bytes(address2Name[msg.sender]).length != 0 ) {
// msg.sender already has a name registered
result = -3;
} else if (name2Address[accountName] != address(0) ) {
// accountName is already taken
result = -4;
} else {
address2Name[msg.sender] = accountName;
name2Address[accountName] = msg.sender;
numOfAccounts++;
result = 0;
}
}
function deleteAccount() public returns (int result) {
if (bytes(address2Name[msg.sender]).length != 0 ) {
string memory _accountName = address2Name[msg.sender];
delete address2Name[msg.sender];
delete name2Address[_accountName];
numOfAccounts -= 1;
result = 0;
} else {
// User does not have an account registered
result = -1;
}
}
function getNumOfAccounts() public view returns (int result) {
result = numOfAccounts;
}
function openRegistrations() public returns (int result) {
if (admin == msg.sender) {
registrationDisabled = false;
} else {
result = -1;
}
}
function closeRegistrations() public returns (int result) {
if (admin == msg.sender) {
registrationDisabled = true;
} else {
result = -1;
}
}
function getAdmin() public view returns(address _address) {
_address = admin;
}
function getAccountName(address _address) public view returns(string memory _name) {
_name = address2Name[_address];
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment