# 智能合约语言

## SOLIDITY <a href="#solidity" id="solidity"></a>

***

* 执行智能合约的目标导向高级语言。
* 受 C++ 影响最深的大括号编程语言。
* 静态类型（编译时已知变量类型）。
* 支持：
  * 继承（您可以拓展其它合约）。
  * 库（您可以创建从不同的合约调用的可重用代码 - 就像静态函数在其它面向对象编程语言的静态类中一样）。
  * 复杂的用户自定义类型。

### 重要链接

* [相关文档(opens in a new tab)](https://docs.soliditylang.org/en/latest/)
* [Solidity 语言网站(opens in a new tab)](https://soliditylang.org/)
* [Solidity 示例(opens in a new tab)](https://docs.soliditylang.org/en/latest/solidity-by-example.html)
* [Solidity Gitter Chatroom(opens in a new tab)](https://gitter.im/ethereum/solidity/) 桥接到 [Solidity Matrix Chatroom(opens in a new tab)](https://matrix.to/#/#ethereum_solidity:gitter.im)
* [备忘单(opens in a new tab)](https://reference.auditless.com/cheatsheet)
* [Solidity 博客(opens in a new tab)](https://blog.soliditylang.org/)
* [Solidity Twitter(opens in a new tab)](https://twitter.com/solidity_lang)

### 合约示例 <a href="#example-contract" id="example-contract"></a>

{% code lineNumbers="true" %}

```asm6502
/ SPDX-License-Identifier: GPL-3.0
pragma solidity >= 0.7.0;

contract Coin {
    // The keyword "public" makes variables
    // accessible from other contracts
    address public minter;
    mapping (address => uint) public balances;

    // Events allow clients to react to specific
    // contract changes you declare
    event Sent(address from, address to, uint amount);

    // Constructor code is only run when the contract
    // is created
    constructor() {
        minter = msg.sender;
    }

    // Sends an amount of newly created coins to an address
    // Can only be called by the contract creator
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount < 1e60);
        balances[receiver] += amount;
    }

    // Sends an amount of existing coins
    // from any caller to an address
    function send(address receiver, uint amount) public {
        require(amount <= balances[msg.sender], "Insufficient balance.");
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Sent(msg.sender, receiver, amount);
    }
}

```

{% endcode %}

这个示例应该能让您感觉到 Solidity 合约语法是什么样子的。 关于函数和变量的详细描述，[请查看文档(opens in a new tab)](https://docs.soliditylang.org/en/latest/contracts.html)。

## VYPER <a href="#vyper" id="vyper"></a>

***

* 类 Python 编程语言
* 强类型
* 小而且易懂的编译器代码
* 高效的字节码生成
* 为了让合约更安全和易于审核，特意提供比 Solidity 少的功能。 Vyper 不支持：
  * 修饰符
  * 继承
  * 内联汇编
  * 函数重载
  * 操作符重载
  * 递归调用
  * 无限长度循环
  * 二进制定长浮点

更多信息，[请查阅 Vyper 原理(opens in a new tab)](https://vyper.readthedocs.io/en/latest/index.html)。

### 重要的链接 <a href="#important-links-1" id="important-links-1"></a>

* [相关文档(opens in a new tab)](https://vyper.readthedocs.io/)
* [Vyper 示例(opens in a new tab)](https://vyper.readthedocs.io/en/latest/vyper-by-example.html)
* [更多 Vyper 示例(opens in a new tab)](https://vyper-by-example.org/)
* [GitHub(opens in a new tab)](https://github.com/vyperlang/vyper)
* [Vyper 社区 Discord 聊天(opens in a new tab)](https://discord.gg/SdvKC79cJk)
* [备忘单(opens in a new tab)](https://reference.auditless.com/cheatsheet)
* [VyperPunk - 学习保护和破解 Vyper 智能合约(opens in a new tab)](https://github.com/SupremacyTeam/VyperPunk)
* [VyperExamples - Vyper 漏洞示例(opens in a new tab)](https://www.vyperexamples.com/reentrancy)
* [Vyper 开发中心(opens in a new tab)](https://github.com/zcor/vyper-dev)
* [Vyper 最热门的智能合约示例(opens in a new tab)](https://github.com/pynchmeister/vyper-greatest-hits/tree/main/contracts)
* [出色的 Vyper 精选资源(opens in a new tab)](https://github.com/spadebuilders/awesome-vyper)

### 合约示例

{% code lineNumbers="true" %}

```asm6502
# Open Auction

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

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

# 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(HashMap[address, uint256])
@external
def __init__(_beneficiary: address, _bidding_time: uint256):
    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.
@external
@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 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.
@external
def withdraw():
    pending_amount: uint256 = 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.
@external
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)

```

{% endcode %}

这个例子应该让您了解 Vyper 合约语法是什么样的。 有关函数和变量的详细说明，[请参阅文档(opens in a new tab)](https://vyper.readthedocs.io/en/latest/vyper-by-example.html#simple-open-auction)。

## YUL 和 YUL+ <a href="#yul" id="yul"></a>

***

如果您是KAD的新手并且尚未使用智能合约语言进行任何编码，我们建议您开始使用 Solidity 或 Vyper。 只有在您熟知智能合约安全最佳做法和使用 EVM 的具体细节后，才可以查看 Yul 或 Yul+。

### **Yul**

* KAD的中继语言。
* 支持 [EVM](https://ethereum.org/zh/developers/docs/evm/) 和 [Ewasm(opens in a new tab)](https://github.com/ewasm)，一种以太坊风格的 WebAssembly，以及旨在成为两个平台均可用的公分母。
* 高级优化阶段的良好目标，既使 EVM 和 eWASM 平台均等受益。

### **Yul+**

* Yul 的低级、高效扩展。
* 最初设计用于乐观卷叠合约。
* Yul+ 可以被视为对 Yul 的实验性升级建议，为其添加新功能。

### 重要的链接 <a href="#important-links-2" id="important-links-2"></a>

* [Yul 相关文档(opens in a new tab)](https://docs.soliditylang.org/en/latest/yul.html)
* [Yul+ 相关文档(opens in a new tab)](https://github.com/fuellabs/yulp)
* [Yul+ 实战场(opens in a new tab)](https://yulp.fuel.sh/)
* [Yul+ 介绍帖子(opens in a new tab)](https://medium.com/@fuellabs/introducing-yul-a-new-low-level-language-for-ethereum-aa64ce89512f)

### 合约示例 <a href="#example-contract-2" id="example-contract-2"></a>

以下简单示例实现了幂函数。 它可以使用 `solc --strict-assembly --bin input.yul` 编译。 这个例子应该 存储在 input.yul 文件中。

{% code lineNumbers="true" fullWidth="false" %}

```asm6502
{
    function power(base, exponent) -> result
    {
        switch exponent
        case 0 { result := 1 }
        case 1 { result := base }
        default
        {
            result := power(mul(base, base), div(exponent, 2))
            if mod(exponent, 2) { result := mul(base, result) }
        }
    }
    let res := power(calldataload(0), calldataload(32))
    mstore(0, res)
    return(0, 32)
}

```

{% endcode %}

如果您已经熟悉智能合约，可以在 [此处找到 Yul 中的完整 ERC20 实例(opens in a new tab)](https://solidity.readthedocs.io/en/latest/yul.html#complete-erc20-example)。

## FE <a href="#fe" id="fe"></a>

***

* KAD虚拟机 (EVM) 静态类型语言。
* 受到 Python 和 Rust 的启发。
* 目标是容易学习 - 甚至对KAD生态系统为新的开发者来说也是如此。
* Fe 开发仍处于早期阶段，该语言于 2021 年 1 月发行。

### 重要链接 <a href="#important-links-3" id="important-links-3"></a>

* [Fe 公告(opens in a new tab)](https://snakecharmers.ethereum.org/fe-a-new-language-for-the-ethereum-ecosystem/)
* [Fe Discord 聊天室(opens in a new tab)](https://discord.com/invite/ywpkAXFjZH)
* [Fe Twitter(opens in a new tab)](https://twitter.com/official_fe)

### 合约示例 <a href="#example-contract-3" id="example-contract-3"></a>

以下是在 Fe 中执行的简单的智能合约。

{% code lineNumbers="true" %}

```asm6502
type BookMsg = bytes[100]

contract GuestBook:
    pub guest_book: map<address, BookMsg>

    event Signed:
        book_msg: BookMsg

    pub def sign(book_msg: BookMsg):
        self.guest_book[msg.sender] = book_msg

        emit Signed(book_msg=book_msg)

    pub def get_msg(addr: address) -> BookMsg:
        return self.guest_book[addr].to_mem()
```

{% endcode %}

## 如何选择 <a href="#how-to-choose" id="how-to-choose"></a>

***

与任何其他编程语言一样，它主要是关于为合适的工作以及个人喜好选择合适的工具。

如果您还没有尝试过任何一种语言，请考虑以下几点：

### Solidity 的优点是什么？ <a href="#solidity-advantages" id="solidity-advantages"></a>

* 如果您是初学者，这里有很多教程和学习工具。 在通过编码学习部分了解更多相关信息。
* 提供出色的开发者工具。
* Solidity 拥有庞大的开发人员社区，这意味着您很可能会很快找到问题的答案。

### Vyper 的优点是什么？ <a href="#vyper-advatages" id="vyper-advatages"></a>

* 想要编写智能合约的 Python 开发人员入门的好方法。
* Vyper 的功能较少，因此非常适合快速制作创意原型。
* Vyper 旨在易于审计并最大限度地提高人类可读性。

### Yul 和 Yul+ 的优点是什么？ <a href="#yul-advantages" id="yul-advantages"></a>

* 简单而实用的低级语言。
* 允许更接近原始 EVM，这有助于优化合约的 gas 使用量。


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://kademliachain.gitbook.io/kad/zhi-neng-he-yue/zhi-neng-he-yue-yu-yan.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.