Solidity

面向 Solidity 智能合约的OOP编程语言

Solidity是一种静态类型、面向合约的高级语言，用于在以太坊区块链平台上实现智能合约。

背景

Solidity是一种静态类型的OOP编程语言，旨在开发在以太坊虚拟机上运行的智能合约。智能合约是在点对点网络中执行的程序，没有人对执行拥有特殊权力，因此它们允许实现价值、所有权、投票和其他类型的逻辑的令牌。

部署合约时，您应该使用最新版本的Solidity。这是因为定期引入突破性更改以及新功能和错误修复。

示例

下面是一个很简单的''Hello, World!"智能合约代码。

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;

contract HelloWorld {
    function helloWorld() external pure returns (string memory) {
        return "Hello, World!";
    }
}

要开始使用Solidity，您可以使用基于浏览器的IDE Remix。以下是一些合同示例：

• 投票

  // SPDX-License-Identifier: GPL-3.0
  pragma solidity >=0.7.0 <0.9.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) {
      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) external {
      // 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) external {
      // 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) external {
      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() external view
          returns (bytes32 winnerName_)
  {
      winnerName_ = proposals[winningProposal()].name;
  }
  }

• 盲拍

  // SPDX-License-Identifier: GPL-3.0
  pragma solidity ^0.8.4;
  contract SimpleAuction {
  // Parameters of the auction. Times are either
  // absolute unix timestamps (seconds since 1970-01-01)
  // or time periods in seconds.
  address payable public beneficiary;
  uint public auctionEndTime;
  
  // Current state of the auction.
  address public highestBidder;
  uint public highestBid;
  
  // Allowed withdrawals of previous bids
  mapping(address => uint) pendingReturns;
  
  // Set to true at the end, disallows any change.
  // By default initialized to `false`.
  bool ended;
  
  // Events that will be emitted on changes.
  event HighestBidIncreased(address bidder, uint amount);
  event AuctionEnded(address winner, uint amount);
  
  // Errors that describe failures.
  
  // The triple-slash comments are so-called natspec
  // comments. They will be shown when the user
  // is asked to confirm a transaction or
  // when an error is displayed.
  
  /// The auction has already ended.
  error AuctionAlreadyEnded();
  /// There is already a higher or equal bid.
  error BidNotHighEnough(uint highestBid);
  /// The auction has not ended yet.
  error AuctionNotYetEnded();
  /// The function auctionEnd has already been called.
  error AuctionEndAlreadyCalled();
  
  /// Create a simple auction with `biddingTime`
  /// seconds bidding time on behalf of the
  /// beneficiary address `beneficiaryAddress`.
  constructor(
      uint biddingTime,
      address payable beneficiaryAddress
  ) {
      beneficiary = beneficiaryAddress;
      auctionEndTime = block.timestamp + biddingTime;
  }
  
  /// Bid on the auction with the value sent
  /// together with this transaction.
  /// The value will only be refunded if the
  /// auction is not won.
  function bid() external payable {
      // No arguments are necessary, all
      // information is already part of
      // the transaction. The keyword payable
      // is required for the function to
      // be able to receive Ether.
  
      // Revert the call if the bidding
      // period is over.
      if (block.timestamp > auctionEndTime)
          revert AuctionAlreadyEnded();
  
      // If the bid is not higher, send the
      // money back (the revert statement
      // will revert all changes in this
      // function execution including
      // it having received the money).
      if (msg.value <= highestBid)
          revert BidNotHighEnough(highestBid);
  
      if (highestBid != 0) {
          // Sending back the money by simply using
          // highestBidder.send(highestBid) is a security risk
          // because it could execute an untrusted contract.
          // It is always safer to let the recipients
          // withdraw their money themselves.
          pendingReturns[highestBidder] += highestBid;
      }
      highestBidder = msg.sender;
      highestBid = msg.value;
      emit HighestBidIncreased(msg.sender, msg.value);
  }
  
  /// Withdraw a bid that was overbid.
  function withdraw() external returns (bool) {
      uint amount = pendingReturns[msg.sender];
      if (amount > 0) {
          // It is important to set this to zero because the recipient
          // can call this function again as part of the receiving call
          // before `send` returns.
          pendingReturns[msg.sender] = 0;
  
          if (!payable(msg.sender).send(amount)) {
              // No need to call throw here, just reset the amount owing
              pendingReturns[msg.sender] = amount;
              return false;
          }
      }
      return true;
  }
  
  /// End the auction and send the highest bid
  /// to the beneficiary.
  function auctionEnd() external {
      // It is a good guideline to structure functions that interact
      // with other contracts (i.e. they call functions or send Ether)
      // into three phases:
      // 1. checking conditions
      // 2. performing actions (potentially changing conditions)
      // 3. interacting with other contracts
      // If these phases are mixed up, the other contract could call
      // back into the current contract and modify the state or cause
      // effects (ether payout) to be performed multiple times.
      // If functions called internally include interaction with external
      // contracts, they also have to be considered interaction with
      // external contracts.
  
      // 1. Conditions
      if (block.timestamp < auctionEndTime)
          revert AuctionNotYetEnded();
      if (ended)
          revert AuctionEndAlreadyCalled();
  
      // 2. Effects
      ended = true;
      emit AuctionEnded(highestBidder, highestBid);
  
      // 3. Interaction
      beneficiary.transfer(highestBid);
  }
  }

文档

Solidity文档托管在Read the docs上。