redsx · November 21, 2021 15:24 · Nov 21, 2021
diff --git a/README.txt b/README.txt
@@ -0,0 +1,18 @@
+REMIX EXAMPLE PROJECT
+
+Remix example project is present when Remix loads very first time or there are no files existing in the File Explorer. 
+It contains 3 directories:
+
+1. 'contracts': Holds three contracts with different complexity level, denoted with number prefix in file name.
+2. 'scripts': Holds two scripts to deploy a contract. It is explained below.
+3. 'tests': Contains one test file for 'Ballot' contract with unit tests in Solidity.
+
+SCRIPTS
+
+The 'scripts' folder contains example async/await scripts for deploying the 'Storage' contract.
+For the deployment of any other contract, 'contractName' and 'constructorArgs' should be updated (along with other code if required). 
+Scripts have full access to the web3.js and ethers.js libraries.
+
+To run a script, right click on file name in the file explorer and click 'Run'. Remember, Solidity file must already be compiled.
+
+Output from script will appear in remix terminal.
diff --git a/contracts...1_Storage.sol b/contracts...1_Storage.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.7.0 <0.9.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;
+    }
+}
diff --git a/contracts...2_Owner.sol b/contracts...2_Owner.sol
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.7.0 <0.9.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() {
+        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;
+    }
+}
diff --git a/contracts...3_Ballot.sol b/contracts...3_Ballot.sol
@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.7.0 <0.9.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) {
+        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;
+    }
+}
diff --git a/scripts...deploy_ethers.js b/scripts...deploy_ethers.js
@@ -0,0 +1,29 @@
+// Right click on the script name and hit "Run" to execute
+(async () => {
+    try {
+        console.log('Running deployWithEthers script...')
+
+        const contractName = 'Storage' // Change this for other contract
+        const constructorArgs = []    // Put constructor args (if any) here for your contract
+
+        // Note that the script needs the ABI which is generated from the compilation artifact.
+        // Make sure contract is compiled and artifacts are generated
+        const artifactsPath = `browser/contracts/artifacts/${contractName}.json` // Change this for different path
+
+        const metadata = JSON.parse(await remix.call('fileManager', 'getFile', artifactsPath))
+        // 'web3Provider' is a remix global variable object
+        const signer = (new ethers.providers.Web3Provider(web3Provider)).getSigner()
+
+        let factory = new ethers.ContractFactory(metadata.abi, metadata.data.bytecode.object, signer);
+
+        let contract = await factory.deploy(...constructorArgs);
+
+        console.log('Contract Address: ', contract.address);
+
+        // The contract is NOT deployed yet; we must wait until it is mined
+        await contract.deployed()
+        console.log('Deployment successful.')
+    } catch (e) {
+        console.log(e.message)
+    }
+})()
diff --git a/scripts...deploy_web3.js b/scripts...deploy_web3.js
@@ -0,0 +1,32 @@
+// Right click on the script name and hit "Run" to execute
+(async () => {
+    try {
+        console.log('Running deployWithWeb3 script...')
+
+        const contractName = 'Storage' // Change this for other contract
+        const constructorArgs = []    // Put constructor args (if any) here for your contract
+
+        // Note that the script needs the ABI which is generated from the compilation artifact.
+        // Make sure contract is compiled and artifacts are generated
+        const artifactsPath = `browser/contracts/artifacts/${contractName}.json` // Change this for different path
+
+        const metadata = JSON.parse(await remix.call('fileManager', 'getFile', artifactsPath))
+        const accounts = await web3.eth.getAccounts()
+
+        let contract = new web3.eth.Contract(metadata.abi)
+
+        contract = contract.deploy({
+            data: metadata.data.bytecode.object,
+            arguments: constructorArgs
+        })
+
+        const newContractInstance = await contract.send({
+            from: accounts[0],
+            gas: 1500000,
+            gasPrice: '30000000000'
+        })
+        console.log('Contract deployed at address: ', newContractInstance.options.address)
+    } catch (e) {
+        console.log(e.message)
+    }
+  })()
diff --git a/tests...4_Ballot_test.sol b/tests...4_Ballot_test.sol
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.7.0 <0.9.0;
+import "remix_tests.sol"; // this import is automatically injected by Remix.
+import "../contracts/3_Ballot.sol";
+
+contract BallotTest {
+
+    bytes32[] proposalNames;
+
+    Ballot ballotToTest;
+    function beforeAll () public {
+        proposalNames.push(bytes32("candidate1"));
+        ballotToTest = new Ballot(proposalNames);
+    }
+
+    function checkWinningProposal () public {
+        ballotToTest.vote(0);
+        Assert.equal(ballotToTest.winningProposal(), uint(0), "proposal at index 0 should be the winning proposal");
+        Assert.equal(ballotToTest.winnerName(), bytes32("candidate1"), "candidate1 should be the winner name");
+    }
+
+    function checkWinninProposalWithReturnValue () public view returns (bool) {
+        return ballotToTest.winningProposal() == 0;
+    }
+}
No results found