Skip to content

Instantly share code, notes, and snippets.

@abirhasanmubin

abirhasanmubin/1_Storage.sol

Created September 30, 2020 14:31
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save abirhasanmubin/ba3b0c1c0841cc0a4930ec1a86a33c4a to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save abirhasanmubin/ba3b0c1c0841cc0a4930ec1a86a33c4a to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. Abir Hasan Mubin created this gist Sep 30, 2020.
    26 changes: 26 additions & 0 deletions 1_Storage.sol
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,26 @@
    pragma solidity >=0.4.22 <0.7.0;

    /**
    * @title Storage
    * @dev Store & retrieve value in a variable
    */
    contract Storage {

    uint256 number;

    /**
    * @dev Store value in variable
    * @param num value to store
    */
    function store(uint256 num) public {
    number = num;
    }

    /**
    * @dev Return value
    * @return value of 'number'
    */
    function retrieve() public view returns (uint256){
    return number;
    }
    }
    49 changes: 49 additions & 0 deletions 2_Owner.sol
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,49 @@
    pragma solidity >=0.4.22 <0.7.0;

    /**
    * @title Owner
    * @dev Set & change owner
    */
    contract Owner {

    address private owner;

    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);

    // modifier to check if caller is owner
    modifier isOwner() {
    // 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 == owner, "Caller is not owner");
    _;
    }

    /**
    * @dev Set contract deployer as owner
    */
    constructor() public {
    owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
    emit OwnerSet(address(0), owner);
    }

    /**
    * @dev Change owner
    * @param newOwner address of new owner
    */
    function changeOwner(address newOwner) public isOwner {
    emit OwnerSet(owner, newOwner);
    owner = newOwner;
    }

    /**
    * @dev Return owner address
    * @return address of owner
    */
    function getOwner() external view returns (address) {
    return owner;
    }
    }
    136 changes: 136 additions & 0 deletions 3_Ballot.sol
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,136 @@
    pragma solidity >=0.4.22 <0.7.0;

    /**
    * @title Ballot
    * @dev Implements voting process along with vote delegation
    */
    contract Ballot {

    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
    }

    struct Proposal {
    // If you can limit the length to a certain number of bytes,
    // always use one of bytes1 to bytes32 because they are much cheaper
    bytes32 name; // short name (up to 32 bytes)
    uint voteCount; // number of accumulated votes
    }

    address public chairperson;

    mapping(address => Voter) public voters;

    Proposal[] public proposals;

    /**
    * @dev Create a new ballot to choose one of 'proposalNames'.
    * @param proposalNames names of proposals
    */
    constructor(bytes32[] memory proposalNames) public {
    chairperson = msg.sender;
    voters[chairperson].weight = 1;

    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
    }));
    }
    }

    /**
    * @dev Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.
    * @param voter address of voter
    */
    function giveRightToVote(address voter) public {
    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;
    }

    /**
    * @dev Delegate your vote to the voter 'to'.
    * @param to address to which vote is delegated
    */
    function delegate(address to) public {
    Voter storage sender = voters[msg.sender];
    require(!sender.voted, "You already voted.");
    require(to != msg.sender, "Self-delegation is disallowed.");

    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.");
    }
    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;
    }
    }

    /**
    * @dev Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.
    * @param proposal index of proposal in the proposals array
    */
    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.
    * @return winningProposal_ index of winning proposal in the proposals array
    */
    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;
    }
    }
    }

    /**
    * @dev Calls winningProposal() function to get the index of the winner contained in the proposals array and then
    * @return winnerName_ the name of the winner
    */
    function winnerName() public view
    returns (bytes32 winnerName_)
    {
    winnerName_ = proposals[winningProposal()].name;
    }
    }
    1 change: 1 addition & 0 deletions abc.sol
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1 @@
    // this line is added to create a gist. Empty file is not allowed.
    187 changes: 187 additions & 0 deletions mainNet.sol
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,187 @@
    pragma solidity >=0.4.22 <0.7.2;
    pragma experimental ABIEncoderV2;

    // "SPDX-License-Identifier: UNLICENSED"



    contract MainContract{

    address owner;
    uint256 public sensorCounter;
    uint256 public dataCounter;
    mapping(uint256=>Sensor) public sensorList; // sensorId -> Sensor
    mapping(uint256=>Data) public dataList; // dataId -> Data
    mapping(string=>uint256) public timeToData; // timein string format -> Data
    // address[] public ownerList;

    // mapping(uint256 => address) sensorOwnerList;

    modifier onlyOwner(){
    require(msg.sender == owner, "Caller is not owner");
    _;
    }

    constructor() public payable{
    owner = msg.sender;
    sensorCounter = 0;
    }

    // struct sensorOwner{
    // uint256 ownerId;
    // uint256[] sensorList; // Sensor Id
    // }

    struct Sensor{
    uint256 sensorId;
    uint256 sensorType;
    uint256[] sensorDataList;
    }

    struct Data{
    uint256 dataId;
    uint256 sensorId;
    uint256 date; // yyyymmdd
    uint256 hour; // 24 hours
    uint256 minute; // 60 minutes
    uint256[] datas; // array of data -> index=>sensorreading; Ex. 0 -> 15.6
    }

    function numberToString(uint v) public returns (string memory) {

    uint length = v/1000 >0 ? 64 : 16;

    bytes memory reversed = new bytes(length);

    uint i = 0;

    while (v != 0) {
    uint remainder = v % 10;
    v = v / 10;
    reversed[i++] = byte(48 + uint8(remainder));
    }

    bytes memory s = new bytes(i + 1);

    for (uint j = 0; j <= i; j++) {
    s[j] = reversed[i - j];
    }

    return string(s);
    }

    function append(string memory a, string memory b, string memory c) public pure returns(string memory){
    return string(abi.encodePacked(a, b, c));
    }

    function dateTime(uint256 _date, uint256 _hour, uint256 _minute) public returns(string memory){
    string memory tempDate = numberToString(_date);

    string memory tempHour = numberToString(_hour);

    string memory tempMinutes = numberToString(_minute);

    return append(tempDate,tempHour,tempMinutes);
    }


    function createData(uint256 _sensorId, uint256 _date, uint256 _hour, uint256 _minute, uint256[] memory _datas) public payable {
    Data memory tempData = Data(dataCounter, _sensorId, _date, _hour, _minute, _datas);
    dataList[dataCounter] = tempData;
    sensorList[_sensorId].sensorDataList.push(dataCounter);
    timeToData[dateTime(_date,_hour,_minute)] = dataCounter;
    dataCounter++;
    }

    function getData(uint256 _dataId) public view returns(Data memory){
    Data memory tempData = dataList[_dataId];
    return tempData;
    }

    function createSensor(uint256 _sensorType) public payable onlyOwner{
    uint256 _sensorId = sensorCounter;
    uint256[] memory notData;
    Sensor memory tempSensor = Sensor(_sensorId,_sensorType, notData);
    sensorCounter++;
    sensorList[_sensorId] = tempSensor;
    }

    function getSensor(uint256 _sensorId) public view returns(uint256[][] memory){
    Sensor memory tempSensor = sensorList[_sensorId] ;
    uint256 size = tempSensor.sensorDataList.length;

    uint256[][] memory temp = new uint256[][](size);

    for (uint i=0; i < size; i++) {

    Data memory tempData = dataList[tempSensor.sensorDataList[i]];

    uint256 len = tempData.datas.length;

    uint256[] memory arr = new uint256[](len);

    arr = tempData.datas;

    temp[i] = arr;
    }

    return temp;
    }

    // function getData(uint256 _dataId) public view returns(uint256, uint256, uint256, uint256, uint256[] memory){

    // }



    // function getTime(uint256 _date, uint256 _hour, uint256 _minute) public pure returns(uint256){

    // uint256 tempTime = _date * 10000;

    // tempTime+= _hour * 100;

    // tempTime+= _minute;

    // return tempTime;
    // }

    // function createData(uint256 _sensorId, uint256 _date, uint256 _hour, uint256 _minute, uint256[] memory _datas) public payable {

    // uint256 Time = getTime(_date, _hour, _minute);

    // dataset[_sensorId].sensorData[Time] = _datas;
    // dataset[_sensorId].dataCount++;

    // }

    // function createSensor(string memory _sensorName) public payable onlyOwner{

    // Sensor memory tempSensor = Sensor(sensorCounter, _sensorName, 0);

    // dataset[sensorCounter]=tempSensor;

    // sensorCounter++;

    // }

    // function getData(uint256 _sensorId, uint256 _date, uint256 _hour, uint256 _minute) public view returns(uint256[] memory){

    // uint256 time = getTime(_date,_hour,_minute);

    // return dataset[_sensorId].sensorData[time];

    // }

    // function getSensor(uint256 _sensorId) public view returns(uint256[] memory){

    // Sensor memory tempSensor = dataset[_sensorId];

    // uint256[] memory memoryArray = new uint256[](tempSensor.dataCount);

    // for(uint256 i=0;i<tempSensor.dataCount;i++){

    // }

    // }

    }
    121 changes: 121 additions & 0 deletions testNet.sol
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,121 @@
    pragma solidity >=0.4.22 <0.7.0;
    pragma experimental ABIEncoderV2;

    // "SPDX-License-Identifier: UNLICENSED"

    contract MainContract{

    address owner;
    uint256 public sensorCounter;
    uint256 public dataCounter;
    mapping(uint256=>Sensor) public sensorList; // sensorId -> Sensor
    mapping(uint256=>Data) public dataList; // dataId -> Data
    mapping(string=>uint256) public timeToData; // timein string format -> Data

    // address[] public ownerList;

    // mapping(uint256 => address) sensorOwnerList;

    modifier onlyOwner(){
    require(msg.sender == owner, "Caller is not owner");
    _;
    }

    constructor() public payable{
    owner = msg.sender;
    sensorCounter = 0;
    }

    // struct sensorOwner{
    // uint256 ownerId;
    // uint256[] sensorList; // Sensor Id
    // }

    struct Sensor{
    uint256 sensorId;
    string _sensorString;
    uint256[] sensorDataList;
    }

    struct Data{
    uint256 dataId;
    uint256 sensorId;
    string time; // yyyymmddHHMM
    // string hour; // 24 hours
    // string minute; // 60 minutes
    uint256[] datas; // array of data -> index=>sensorreading; Ex. 0 -> 15.6
    }

    function dateToString(string memory _date, string memory _hour, string memory _minute) public pure returns(string memory){
    // return string(abi.encodePacked(_date, _hour, _minute));

    bytes memory _ba = bytes(_date);
    bytes memory _bb = bytes(_hour);
    bytes memory _bc = bytes(_minute);
    string memory abcde = new string(_ba.length + _bb.length + _bc.length);
    bytes memory babcde = bytes(abcde);
    uint k = 0;

    for (uint i = 0; i < _ba.length; i++) {
    babcde[k++] = _ba[i];
    }

    for(uint i = 0; i < _bb.length; i++){
    babcde[k++] = _bb[i];
    }

    for(uint i = 0; i < _bc.length; i++){
    babcde[k++] = _bc[i];
    }

    return string(babcde);
    }

    function createData(uint256 _sensorId, string memory _time, uint256[] memory _datas) public payable {
    Data memory tempData = Data(dataCounter, _sensorId, _time, _datas);
    dataList[dataCounter] = tempData;
    sensorList[_sensorId].sensorDataList.push(dataCounter);
    timeToData[_time] = dataCounter;
    dataCounter++;
    }

    function getData(uint256 _dataId) public view returns(uint256[] memory){
    Data memory tempData = dataList[_dataId];
    return tempData.datas;
    }

    function createSensor(string memory _sensorString) public payable onlyOwner{
    uint256 _sensorId = sensorCounter;
    uint256[] memory notData;
    Sensor memory tempSensor = Sensor(_sensorId, _sensorString, notData);
    sensorCounter++;
    sensorList[_sensorId] = tempSensor;
    }

    function getSensor(uint256 _sensorId) public view returns(uint256[][] memory){
    Sensor memory tempSensor = sensorList[_sensorId];
    uint256 size = tempSensor.sensorDataList.length;

    uint256[][] memory temp = new uint256[][](size);

    for (uint i = 0; i < size; i++) {
    Data memory tempData = dataList[tempSensor.sensorDataList[i]];
    uint256 len = tempData.datas.length;
    uint256[] memory arr = new uint256[](len);
    arr = tempData.datas;
    temp[i] = arr;
    }
    return temp;
    }

    function getSenesorList() public view returns(string[] memory){
    string[] memory tempSensorList;

    for(uint i = 0; i < sensorCounter; i++){
    Sensor memory tempSensor = sensorList[i];
    tempSensorList[i]=tempSensor._sensorString;
    }

    return tempSensorList;
    }
    }