• 官方文件：https://vyper.readthedocs.io/en/v0.1.0-beta.8/

現在除了 Solidity 之外，多了一個 Vyper 可以選。

Solidity vs Vyper

• Vyper 語法接近 Python，Solidity 語法接近 Javascript。
• Vyper 從 Solidity 過去的經驗，提供更安全的程式語言。
• Vyper 提供更可讀的語法
• Vyper 可以用 python 體系下的 virtualenv 來編譯，Solidity 可以用 Javascript 體系下的 solc 來編譯。

pip install vyper
pip install vyper==0.1.0b2
vyper examples.vy

目前 Vyper 還有點太年輕，學習資源也不多，多數人還是保持觀望的態度。

你可以從 https://github.com/ethereum/vyper/wiki/Vyper-tools-and-resources 找到更多的資訊。

資料來源

• Is Vyper a good alternative to Solidity?
• Ethereum ditching Solidity for Vyper?

延伸閱讀

• vyper 原始碼：https://github.com/ethereum/vyper
• virtualenv：https://virtualenv.pypa.io/en/stable/
• vyper-remix：https://github.com/GrandSchtroumpf/vyper-remix

範例

# Open Auction

# Auction params
# Beneficiary receives money from the highest bidder
beneficiary: public(address)
auctionStart: public(timestamp)
auctionEnd: public(timestamp)

# Current state of auction
highestBidder: public(address)
highestBid: public(wei_value)

# Set to true at the end, disallows any change
ended: public(bool)

# Keep track of refunded bids so we can follow the withdraw pattern
pendingReturns: public(map(address, wei_value))

# Create a simple auction with `_bidding_time`
# seconds bidding time on behalf of the
# beneficiary address `_beneficiary`.
@public
def __init__(_beneficiary: address, _bidding_time: timedelta):
    self.beneficiary = _beneficiary
    self.auctionStart = block.timestamp
    self.auctionEnd = self.auctionStart + _bidding_time

# Bid on the auction with the value sent
# together with this transaction.
# The value will only be refunded if the
# auction is not won.
@public
@payable
def bid():
    # Check if bidding period is over.
    assert block.timestamp < self.auctionEnd
    # Check if bid is high enough
    assert msg.value > self.highestBid
    # Track the refund for the previous high bidder
    self.pendingReturns[self.highestBidder] += self.highestBid
    # Track new high bid
    self.highestBidder = msg.sender
    self.highestBid = msg.value

# Withdraw a previously refunded bid. The withdraw pattern is
# used here to avoid a security issue. If refunds were directly
# sent as part of bid(), a malicious bidding contract could block
# those refunds and thus block new higher bids from coming in.
@public
def withdraw():
    pending_amount: wei_value = self.pendingReturns[msg.sender]
    self.pendingReturns[msg.sender] = 0
    send(msg.sender, pending_amount)

# End the auction and send the highest bid
# to the beneficiary.
@public
def endAuction():
    # 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
    # Check if auction endtime has been reached
    assert block.timestamp >= self.auctionEnd
    # Check if this function has already been called
    assert not self.ended

    # 2. Effects
    self.ended = True

    # 3. Interaction
    send(self.beneficiary, self.highestBid)