Solidity 0.5.8官方文档

智能合约简介
实例 - 简单存储合约 实例 - 简单子货币合约 区块链基础知识
以太坊虚拟机简介
EVM - 账户 EVM - 交易 EVM - Gas EVM - 内存/存储/栈 EVM - 指令集 EVM - 消息调用 EVM - 委托调用/调用代码/库 EVM - 日志 EVM - 创建其他合约 EVM - 合约停用与自毁
安装Solidity编译器
Solidity编译器版本概述 使用在线Solidity IDE - Remix 使用npm安装Solidity编译器 使用Solidity编译器Docker镜像 安装预构建Solidity编译器 使用源代码构建Solidity编译器
利用实例学习Solidity
实例 - 投票合约 实例 - 盲拍合约 实例 - 安全远程购买合约 实例 - 微支付通道 实例 - 模块化合约
Solidity源文件布局
Pragma - Solidity编译控制指令 导入其他Solidity文件 在Solidity中使用注释
Solidity智能合约的结构
合约 - 状态变量 合约 - 函数 合约 - 函数修饰符 合约 - 事件 合约 - 结构类型 合约 - 枚举类型
Solidity值数据类型
布尔类型 整型 定长浮点数 地址类型 定长字节数组 变长字节数组 地址字面量 数值字面量 字符串字面量 十六进制字面量 枚举类型 数类型
Solidity其他数据类型
引用类型 映射类型 LValue相关的操作符 基本类型之间的转换 字面量类型推断
Solidity内置的计量单位及全局变量
以太币计量单位 时间单位 特殊变量与特殊函数
Solidity表达式和逻辑控制结构
逻辑控制结构 函数调用 使用new创建合约实例 表达式执行顺序 赋值 变量声明与作用域
Solidity智能合约
创建合约 可视性与getter函数 函数修饰符 状态常量 函数参数与返回值 只读函数 纯函数 回退函数 函数重载 使用日志 合约的构造函数 基类构造函数的参数 多重继承与线性化 同名不同类型成员的继承 抽象合约 接口 using for指令
Solidity汇编
内联汇编 - 语法 内联汇编 - 示例 内联汇编 - 操作符 内联汇编 - 字面量 内联汇编 - 函数式风格 内联汇编 - 访问外部变量/函数/库 内联汇编 - 标签 内联汇编 - 声明本地变量 内联汇编 - 赋值 内联汇编 - 条件语句 内联汇编 - 分支语句 内联汇编 - 循环语句 内联汇编 - 函数 使用内联汇编需要避免的错误 Solidity中的惯例 独立汇编的语法
Solidity其他问题
存储中的状态变量布局 内存中的布局 调用数据的布局 变量清理的内部机制 优化器的内部机制 源代码映射 技巧及小窍门
Solidity速查表
操作符优先级 全局变量 函数可见性声明符 修饰符 保留关键字 Solidity语法
NatSpec格式
NatSpec文档示例 使用NatSpec标签 NatSpec文档输出
Solidity安全陷阱
安全陷阱 - 私有信息与随机性 安全陷阱 - 重入问题 安全陷阱 - Gas限量与循环 安全陷阱 - 以太币的发送与接收 安全陷阱 - 调用栈的深度 安全陷阱 - 谨慎使用tx.origin 安全陷阱 - 2的补数/下界溢出/上界溢出 安全相关的小细节
Solidity安全推荐做法
安全推荐 - 认真对待警告信息 安全推荐 - 限定以太币的数量 安全推荐 - 保持合约的简洁与模块化 安全推荐 - 使用检查/生效/交互模式 安全推荐 - 引入故障安全运行模式 安全推荐 - 提请他人审核代码
Solidity安全的正式验证
安全验证 - 抽象与误报 安全验证 - 引用类型与别名
Solidity资源
常规资源 支持Solidity集成的在线服务 Solidity工具 第三方Solidity解析器和语法器
使用Solidity编译器
使用命令行编译器 设置目标EVM版本 编译器输入/输出JSON格式说明
Solidity合约元数据
在合约字节码中嵌入元数据 使用元数据自动生成接口及NatSpec文档 使用元数据进行源代码验证
Solidity合约ABI规范
ABI - 基本设计 ABI - 函数选择符 ABI - 参数编码 ABI - 数据类型 ABI - 编码设计条件 ABI - 编码的形式化约定 ABI - 函数选择符与参数编码 ABI - 示例 ABI - 使用动态类型 ABI - JSON格式 ABI - 严格编码格式 ABI - 非标压缩格式 ABI - 有索引事件参数的编码
Yul规范
Yul - 语法的局限性 Yul - 作用域规则 Yul - 形式化定义 Yul - 类型转换函数 Yul - 底层函数 Yul - 后端 Yul - 对象规范
Solidity风格指南
风格指南简介 代码布局指南 代码布局的顺序 命名惯例 NatSpec风格
Solidity常见模式
模式 - 从合约提款 模式 - 访问限制 模式 - 状态机
在线工具推荐: Three.js AI纹理开发包 - YOLO合成数据生成器 - GLTF/GLB在线编辑 - 3D模型格式在线转换 - 可编程3D场景编辑器

实例 - 投票合约

以下的合约相当复杂,但展示了很多Solidity的功能。它实现了一个投票合约。 当然,电子投票的主要问题是如何将投票权分配给正确的人员以及如何防止被操纵。 我们不会在这里解决所有的问题,但至少我们会展示如何进行委托投票,同时,计票又是 自动和完全透明的 。

我们的想法是为每个(投票)表决创建一份合约,为每个选项提供简称。 然后作为合约的创造者——即主席,将给予每个独立的地址以投票权。

地址后面的人可以选择自己投票,或者委托给他们信任的人来投票。

在投票时间结束时,winningProposal() 将返回获得最多投票的提案。

pragma solidity ^0.4.22;

/// @title 委托投票
contract Ballot {
    // 这里声明了一个新的复合类型用于稍后的变量
    // 它用来表示一个选民
    struct Voter {
        uint weight; // 计票的权重
        bool voted;  // 若为真,代表该人已投票
        address delegate; // 被委托人
        uint vote;   // 投票提案的索引
    }

    // 提案的类型
    struct Proposal {
        bytes32 name;   // 简称(最长32个字节)
        uint voteCount; // 得票数
    }

    address public chairperson;

    // 这声明了一个状态变量,为每个可能的地址存储一个 `Voter`。
    mapping(address => Voter) public voters;

    // 一个 `Proposal` 结构类型的动态数组
    Proposal[] public proposals;

    /// 为 `proposalNames` 中的每个提案,创建一个新的(投票)表决
    constructor(bytes32[] proposalNames) public {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;
        //对于提供的每个提案名称,
        //创建一个新的 Proposal 对象并把它添加到数组的末尾。
        for (uint i = 0; i < proposalNames.length; i++) {
            // `Proposal({...})` 创建一个临时 Proposal 对象,
            // `proposals.push(...)` 将其添加到 `proposals` 的末尾
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }

    // 授权 `voter` 对这个(投票)表决进行投票
    // 只有 `chairperson` 可以调用该函数。
    function giveRightToVote(address voter) public {
        // 若 `require` 的第一个参数的计算结果为 `false`,
        // 则终止执行,撤销所有对状态和以太币余额的改动。
        // 在旧版的 EVM 中这曾经会消耗所有 gas,但现在不会了。
        // 使用 require 来检查函数是否被正确地调用,是一个好习惯。
        // 你也可以在 require 的第二个参数中提供一个对错误情况的解释。
        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;
    }

    /// 把你的投票委托到投票者 `to`。
    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.");

        // 委托是可以传递的,只要被委托者 `to` 也设置了委托。
        // 一般来说,这种循环委托是危险的。因为,如果传递的链条太长,
        // 则可能需消耗的gas要多于区块中剩余的(大于区块设置的gasLimit),
        // 这种情况下,委托不会被执行。
        // 而在另一些情况下,如果形成闭环,则会让合约完全卡住。
        while (voters[to].delegate != address(0)) {
            to = voters[to].delegate;

            // 不允许闭环委托
            require(to != msg.sender, "Found loop in delegation.");
        }

        // `sender` 是一个引用, 相当于对 `voters[msg.sender].voted` 进行修改
        sender.voted = true;
        sender.delegate = to;
        Voter storage delegate_ = voters[to];
        if (delegate_.voted) {
            // 若被委托者已经投过票了,直接增加得票数
            proposals[delegate_.vote].voteCount += sender.weight;
        } else {
            // 若被委托者还没投票,增加委托者的权重
            delegate_.weight += sender.weight;
        }
    }

    /// 把你的票(包括委托给你的票),
    /// 投给提案 `proposals[proposal].name`.
    function vote(uint proposal) public {
        Voter storage sender = voters[msg.sender];
        require(!sender.voted, "Already voted.");
        sender.voted = true;
        sender.vote = proposal;

        // 如果 `proposal` 超过了数组的范围,则会自动抛出异常,并恢复所有的改动
        proposals[proposal].voteCount += sender.weight;
    }

    /// @dev 结合之前所有的投票,计算出最终胜出的提案
    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;
            }
        }
    }

    // 调用 winningProposal() 函数以获取提案数组中获胜者的索引,并以此返回获胜者的名称
    function winnerName() public view
            returns (bytes32 winnerName_)
    {
        winnerName_ = proposals[winningProposal()].name;
    }
}

可能的优化

当前,为了把投票权分配给所有参与者,需要执行很多交易。你有没有更好的主意?