Глубокое погружение в смарт-контракты

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;


/********************************************************/
/* For learning purposes ONLY. Do not use in production */
/********************************************************/


// Download into project folder with `npm install @openzeppelin/contracts`
import "@openzeppelin/contracts/access/Ownable.sol";

// Inherits the Ownable contract so we can use its functions and modifiers
contract HOABallot is Ownable {

    // Custom type to describe a Presidential Candidate and hold votes
    struct Candidate {
        string name;
        uint256 votes;
    }

    // Array of Presidential Candidates
    Candidate[] public candidates;


    // Add a President Candidate - onlyOwner
    function addCandidate(string memory _name) public onlyOwner {
        require(bytes(_name).length > 0, "addCandidate Error: Please enter a name");
        candidates.push(Candidate({name: _name, votes: 0}));
    }


    // Remove a Candidate - onlyOwner
    function removeCandidate(string memory _name) public onlyOwner {
        require(bytes(_name).length > 0, "removeCandidate Error: Please enter a name");
        bool foundCandidate = false;
        uint256 index;
        bytes32 nameEncoded = keccak256(abi.encodePacked(_name));

        // Set index number for specific candidate
        for (uint256 i = 0; i < candidates.length; i++) {
            if (keccak256(abi.encodePacked(candidates[i].name)) == nameEncoded) {
                index = i;
                foundCandidate = true;
            }
        }

        // Make sure a candidate was found
        require(foundCandidate, "removeCandidate Error: Candidate not found");

        // shift candidate to be removed to the end of the array and the rest forward
        for (uint256 i = index; i < candidates.length - 1; i++) {
            candidates[i] = candidates[i + 1];
        }

        // remove last item from array
        candidates.pop();
    }


    // Reset the President Vote Counts - onlyOwner
    function resetVoteCount() public onlyOwner {
        for (uint256 p = 0; p < candidates.length; p++) {
            candidates[p].votes = 0;
        }
    }


    // Add a vote to a candidate by name
    function addVoteByName(string memory _name) public {
        require(bytes(_name).length > 0, "addVoteByName Error: Please enter a name");
        // Encode name so only need to do once
        bytes32 nameEncoded = keccak256(abi.encodePacked(_name));

        for (uint256 i = 0; i < candidates.length; i++) {
            // solidity can't compare strings directly, need to compare hash
            if (keccak256(abi.encodePacked(candidates[i].name)) == nameEncoded) {
                candidates[i].votes += 1;
            }
        }
    }


    // Returns all the Presidential Candidates and their vote counts
    function getCandidates() public view returns (Candidate[] memory) {
        return candidates;
    }


    function getWinner() public view returns (Candidate memory winner) {
        uint256 winningVoteCount = 0;
        for (uint256 i = 0; i < candidates.length; i++) {
            if (candidates[i].votes > winningVoteCount) {
                winningVoteCount = candidates[i].votes;
                winner = candidates[i];
            }
        }

        return winner;
    }

}

npm install -g truffle

mkdir hoa-ballot-contract && cd hoa-ballot-contract
truffle init

npm install @openzeppelin/contracts

networks: {
  dashboard: {
    port: 24012,
  }
}

const HOABallot = artifacts.require("HOABallot");

Module.exports = function (deployer) {
  deployer.deploy(HOABallot);
}

truffle dashboard

truffle migrate --network dashboard

2_hoaballot_migration.js
========================

   Deploying 'HOABallot'
   ---------------------
   > transaction hash:    0x5370b6f9ee1f69e92cc6289f9cb0880386f15bff389b54ab09a966c5d144f59esage.
   > Blocks: 0            Seconds: 32
   > contract address:    0x2981d347e288E2A4040a3C17c7e5985422e3cAf2
   > block number:        12479257
   > block timestamp:     1656386400
   > account:             0x7fC3EF335D16C0Fd4905d2C44f49b29BdC233C94
   > balance:             41.088173901232893417
   > gas used:            1639525 (0x190465)
   > gas price:           2.50000001 gwei
   > value sent:          0 ETH
   > total cost:          0.00409881251639525 ETH

   > Saving migration to chain.
   > Saving artifacts
   -------------------------------------
   > Total cost:     0.00409881251639525 ETH

Summary
=======
> Total deployments:   1
> Final cost:          0.00409881251639525 ETH

npx create-react-app hoa-ballot-client

cd hoa-ballot-client
npm install web3
npm install @openzeppelin/contracts —save

export const hoaBallot = [
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "previousOwner",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "newOwner",
        "type": "address"
      }
    ],
    "name": "OwnershipTransferred",
    "type": "event"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "name": "candidates",
    "outputs": [
      {
        "internalType": "string",
        "name": "name",
        "type": "string"
      },
      {
        "internalType": "uint256",
        "name": "votes",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function",
    "constant": true
  },
  {
    "inputs": [],
    "name": "owner",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function",
    "constant": true
  },
  {
    "inputs": [],
    "name": "renounceOwnership",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "newOwner",
        "type": "address"
      }
    ],
    "name": "transferOwnership",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "string",
        "name": "_name",
        "type": "string"
      }
    ],
    "name": "addCandidate",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "string",
        "name": "_name",
        "type": "string"
      }
    ],
    "name": "removeCandidate",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "resetVoteCount",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "string",
        "name": "_name",
        "type": "string"
      }
    ],
    "name": "addVoteByName",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "getCandidates",
    "outputs": [
      {
        "components": [
          {
            "internalType": "string",
            "name": "name",
            "type": "string"
          },
          {
            "internalType": "uint256",
            "name": "votes",
            "type": "uint256"
          }
        ],
        "internalType": "struct HOABallot.Candidate[]",
        "name": "",
        "type": "tuple[]"
      }
    ],
    "stateMutability": "view",
    "type": "function",
    "constant": true
  },
  {
    "inputs": [],
    "name": "getWinner",
    "outputs": [
      {
        "components": [
          {
            "internalType": "string",
            "name": "name",
            "type": "string"
          },
          {
            "internalType": "uint256",
            "name": "votes",
            "type": "uint256"
          }
        ],
        "internalType": "struct HOABallot.Candidate",
        "name": "winner",
        "type": "tuple"
      }
    ],
    "stateMutability": "view",
    "type": "function",
    "constant": true
  }
];

import React, { useState } from "react";
import { hoaBallot } from "./abi/abi";
import Web3 from "web3";
import "./App.css";

const web3 = new Web3(Web3.givenProvider);
const contractAddress = "0x2981d347e288E2A4040a3C17c7e5985422e3cAf2";
const storageContract = new web3.eth.Contract(hoaBallot, contractAddress);

const web3 = new Web3(Web3.givenProvider);
const contractAddress = "0x2981d347e288E2A4040a3C17c7e5985422e3cAf2";
const storageContract = new web3.eth.Contract(hoaBallot, contractAddress);
const gasMultiplier = 1.5;

const useStyles = makeStyles((theme) => ({
  root: {
    "& > *": {
      margin: theme.spacing(1),
    },
  },
}));

const StyledTableCell = styled(TableCell)(({ theme }) => ({

    backgroundColor: theme.palette.common.black,
    color: theme.palette.common.white,
    fontSize: 14,
    fontWeight: 'bold'
  },

    fontSize: 14
  },
}));

function App() {
  const classes = useStyles();
  const [newCandidateName, setNewCandidateName] = useState("");
  const [account, setAccount] = useState("");
  const [owner, setOwner] = useState("");
  const [candidates, updateCandidates] = useState([]);
  const [winner, setWinner] = useState("unknown candidate");
  const [waiting, setWaiting] = useState(false);

  const loadAccount = async(useSpinner) => {
    if (useSpinner) {
      setWaiting(true);
    }

    const web3 = new Web3(Web3.givenProvider || "http://localhost:8080");
    const accounts = await web3.eth.getAccounts();
    setAccount(accounts[0]);

    if (useSpinner) {
      setWaiting(false);
    }
  }

  const getOwner = async (useSpinner) => {
    if (useSpinner) {
      setWaiting(true);
    }

    const owner = await storageContract.methods.owner().call();
    setOwner(owner);

    if (useSpinner) {
      setWaiting(false);
    }
  };

  const getCandidates = async (useSpinner) => {
    if (useSpinner) {
      setWaiting(true);
    }

    const candidates = await storageContract.methods.getCandidates().call();

    updateCandidates(candidates);

    await determineWinner();

    if (useSpinner) {
      setWaiting(false);
    }
  };

  const determineWinner = async () => {
    const winner = await storageContract.methods.getWinner().call();

    if (winner && winner.name) {
      setWinner(winner.name);
    } else {
      setWinner("<unknown candidate>")
    }
  }

  const vote = async (candidate) => {
    setWaiting(true);

    const gas = (await storageContract.methods.addVoteByName(candidate).estimateGas({
      data: candidate,
      from: account
    })) * gasMultiplier;

    let gasAsInt = gas.toFixed(0);

    await storageContract.methods.addVoteByName(candidate).send({
      from: account,
      data: candidate,
      gasAsInt,
    });

    await getCandidates(false);

    setWaiting(false);
  }

  const removeCandidate = async (candidate) => {
    setWaiting(true);

    const gas = (await storageContract.methods.removeCandidate(candidate).estimateGas({
      data: candidate,
      from: account
    })) * gasMultiplier;

    let gasAsInt = gas.toFixed(0);

    await storageContract.methods.removeCandidate(candidate).send({
      from: account,
      data: candidate,
      gasAsInt,
    });

    await getCandidates(false);

    setWaiting(false);
  }

  const addCandidate = async () => {
    setWaiting(true);

    const gas = (await storageContract.methods.addCandidate(newCandidateName).estimateGas({
      data: newCandidateName,
      from: account
    })) * gasMultiplier;

    let gasAsInt = gas.toFixed(0);

    await storageContract.methods.addCandidate(newCandidateName).send({
      from: account,
      data: newCandidateName,
      gasAsInt,
    });

    await getCandidates(false);

    setWaiting(false);
  }

  React.useEffect(() => {
    setWaiting(true);
    getOwner(false).then(r => {
      loadAccount(false).then(r => {
        getCandidates(false).then(r => {
          setWaiting(false);
        });
      });
    });

    // eslint-disable-next-line react-hooks/exhaustive-deps
  },[]);

  return (
      <div className={classes.root}>
        <Nav />
        <div className="main">
          <div className="card">
            <Typography variant="h3">
              HOABallot
            </Typography>

            {(owner && owner.length > 0) && (
                <div className="paddingBelow">
                  <Typography variant="caption" >
                    This ballot is owned by: {owner}
                  </Typography>
                </div>
            )}

            {waiting && (
                <div className="spinnerArea" >
                  <CircularProgress />
                  <Typography gutterBottom>
                    Processing Request ... please wait
                  </Typography>
                </div>
            )}

            {(owner && owner.length > 0 && account && account.length > 0 && owner === account) && (
                <div className="ownerActions generalPadding">
                  <Grid container spacing={3}>
                    <Grid item xs={12}>
                      <Typography variant="h6" gutterBottom>
                        Ballot Owner Actions
                      </Typography>
                    </Grid>
                    <Grid item xs={6} sm={6}>
                      <TextField id="newCandidateName"
                                 value={newCandidateName}
                                 label="Candidate Name"
                                 variant="outlined"
                                 onChange={event => {
                                   const { value } = event.target;
                                   setNewCandidateName(value);
                                 }}
                      />
                    </Grid>
                    <Grid item xs={6} sm={6}>
                      <Button
                          id="addCandidateButton"
                          className="button"
                          variant="contained"
                          color="primary"
                          type="button"
                          size="large"
                          onClick={addCandidate}>Add New Candidate</Button>
                    </Grid>
                  </Grid>
                </div>
            )}

            <Typography variant="h5" gutterBottom className="generalPadding">
              Candidates
            </Typography>

            {(!candidates || candidates.length === 0) && (
                <div>
                  <div className="paddingBelow">
                    <Typography variant="normal">
                      No candidates current exist.
                    </Typography>
                  </div>
                  <div>
                    <Typography variant="normal" gutterBottom>
                      Ballot owner must use the <strong>ADD NEW CANDIDATE</strong> button to add candidates.
                    </Typography>
                  </div>
                </div>
            )}

            {(candidates && candidates.length > 0) && (
                <div>
                  <TableContainer component={Paper}>
                    <Table sx={{ minWidth: 650 }} aria-label="customized table">
                      <TableHead>
                        <TableRow>
                          <StyledTableCell>Candidate Name</StyledTableCell>
                          <StyledTableCell align="right">Votes</StyledTableCell>
                          <StyledTableCell align="center">Actions</StyledTableCell>
                        </TableRow>
                      </TableHead>
                      <TableBody>
                        {candidates.map((row) => (
                            <TableRow
                                key={row.name}
                                sx={{ '&:last-child td, &:last-child th': { border: 0 } }}
                            >
                              <TableCell component="th" scope="row">
                                {row.name}
                              </TableCell>
                              <TableCell align="right">{row.votes}</TableCell>
                              <TableCell align="center">
                                <Button
                                    color="success"
                                    variant="contained"
                                    onClick={() => {
                                      vote(row.name);
                                    }}
                                >
                                    Vote
                                </Button> &nbsp;
                                {(owner && owner.length > 0 && account && account.length > 0 && owner === account) &&
                                  <Button
                                      color="error"
                                      variant="contained"
                                      onClick={() => {
                                        removeCandidate(row.name);
                                      }}
                                  >
                                    Remove Candidate
                                  </Button>
                                }
                              </TableCell>
                            </TableRow>
                        ))}
                      </TableBody>
                    </Table>
                  </TableContainer>
                  <div className="generalPadding">
                    <Typography variant="normal" gutterBottom>
                      {winner} is winning the election.
                    </Typography>
                  </div>

                </div>
            )}
          </div>
        </div>
      </div>
  );
}

export default App;

yarn start