加密日记【020】全面掌握Solidity开发
0x3c
0xF3f2
May 15th, 2023

事件

在定义事件的时候，前三个参数可以定义为indexed，方便在区块链里面扫描查找，indexed的参数会存储在topics下面

immutable (不可变量)与constant(常量)

Solidity 0.6.5 更新引入了一个新的关键字 immutable

constant 修饰的变量需要在编译期确定值, 链上不会为这个变量分配存储空间, 它会在编译时用具体的值替代, 因此, constant常量是不支持使用运行时状态赋值的(例如:  block.number ,  now ,  msg.sender  等 )。constant 目前仅支持修饰 strings 及 值类型.

immutable 修饰的变量是在部署的时候确定变量的值, 所以写在构造函数中。它在构造函数中赋值一次之后,就不在改变, 这是一个运行时赋值, 就可以解除之前 constant 不支持使用运行时状态赋值的限制.

Solidity 0.6.x更新

  1. 继承
contract Part1 {
  constructor() public {}
}
contract Part2 {
  constructor() public {}
}
contract Child is Part1, Part2 {
  constructor() public {}

}

继承顺序是Child⇒ Part2⇒Part，先继承Part2，再继承Part1

在这次更新之后，如果继承的多个合约中有相同的函数，编译器会报错，必须override()父合约，重写函数内容

pragma solidity ^0.6.10;
contract A {
    uint public x;
    function setValue(uint _x) public virtual {
        x = _x;
    }
}

contract B {
    uint public y;
    function setValue(uint _y) public virtual {
        y = _y;
    }
}

contract C is A, B {
    function setValue(uint _x) public override(A,B) {
        A.setValue(_x);
    }

  • 只有标记为virtual的函数才可以重写它们。 此外，任何重写的函数都必须标记为override 。 如果重写后依旧是可重写的，则仍然需要标记为virtual

  • 关键字super的工作原理与以前相同：在扁平化继承层次结构中，super将函数调用到更上一级的函数。 外部函数（external函数）仍然不允许使用super

  • 接口（interface）的函数都是隐式虚函数的，因此在实现接口时，必须在实现中显式重写其函数

  1. 接口可以继承

    允许接口继承接口。 派生的接口是的所有接口函数的组合。 实现合约必须实现的所有继承接口的函数,如果合约未实现所有函数，则必须将合约标记为abstract

    pragma solidity ^0.6.10;
interface X {
    function setValue(uint _x) external;
}

interface Y is X {
    function getValue() external returns (uint);
}

contract Z is Y {
    uint x;
    function setValue(uint _x) external override { x = _x; }
    function getValue() external override returns (uint) { return x; }
}
abstract contract N is Y {
    uint x;
    function setValue(uint _x) external override { x = _x; }
}

  2. 抽象合约

    0.5版本编译器隐式地将未实现其所有函数的合约当作是抽象合约。0.6必须显式的指定abstract

  3. public的返回类型必须一致

  4. 不再有状态变量遮蔽

    在继承的合约和本合约中有相同函数名称和变量名称，会报错

  5. 引入try/catch

    • 这是仅仅提供给外部调用的特性，部署新合约也被视为外部调用。不可以和低级调用一起使用。

    • 该功能能够捕获仅在调用内部产生的异常。调用后的 try 代码块是在成功之后执行。不会捕获try 代码块中的任何异常。

    • 如果函数调用返回一些变量，则可以在以下执行块中使用它们（如以上示例中所述）。

      • 如果执行了 try 成功代码块，则必须声明与函数调用实际返回值相同类型的变量。

      • 如果执行了低级的catch块，则返回值是类型为bytes的变量。任何特定条件的catch子句都有其自己的返回值类型。

    • 请记住，低级catch (bytes memory returnData) 子句能够捕获所有异常，而特定条件的catch子句只捕获对应的错误。处理各种异常时，请考虑同时使用两者。

    • 在为 try 外部调用设置特定的gas使用量时，低级的catch子句会捕获最终的out of gas错误。 但如果交易本身没有足够的 gas执行代码，则out of gas是没法捕获的。

Solidity 0.8.x更新

  1. 会自动检查溢出，如果默认可以溢出，用unchecked

  2. 无效的操作码被还原取代，这样就不会把剩余的gas消耗掉

  • ABIEncoderV2现在是默认自动激活。 从0.6开始，Encoder就不再是实验性的了，只是因为遗留的原因，保留了 pragma experimental 这个名字。 现在你不需要再加这行了。

  • 移除任何Openzeppelin SafeMath，你不再需要它了。

  • 可能需要进行一些类型转换。

    • msg.sender 和 tx.origin 默认不属于payable类型。 将 msg.sender.transfer 改为 payable(msg.sender).transfer。

    • 只有在符合给定类型的情况下，才允许类型转换，所以uint256(-1)将不再工作。 使用type(uint256).max代替。

    • 当多次改变符号时，类型转换在某些情况下会受到限制，因为类型转换的顺序可能会对结果产生影响。 你现在会看到一个类似TypeError的错误。 不允许从 int256 到 bytes32 进行显示的类型转换，得先手动转换为uint256。

  • 修饰组合

    • myContract.functionCall{gas: 10000}{value: 1 ether }()改为：

    • myContract.functionCall{gas: 10000, value: 1 ether }()。

  • 将 x**y**z 改为(x**y)**z，因为默认的执行顺序改变了。

  • 将 byte 类型改为 byte1 。

Solidity v0.8.0 Breaking Changes — Solidity 0.8.30 documentation
docs.soliditylang.org

以太坊合约委托调用（DelegateCall）

当我们说“函数被调用”时，这意味着我们将特定的上下文(如参数)注入到该组命令(函数)中，并且在此上下文中一个接一个地执行命令。

函数、命令组、地址空间可以通过其名称找到。

在以太坊函数中，调用可以用字节码表示，使用 4 + 32 * N个字节表达。这个字节码由两部分组成。

  • 函数选择器：这是函数调用字节码的前4个字节。函数选择器是通过对目标函数的名称加上其参数类型(不包括空格)进行哈希（keccak-256哈希函数）取前 4 个字节得到，例如bytes4(keccak-256(“saveValue(uint)”))。基于此函数选择器，EVM可以决定应在合约中调用哪个函数。

  • 函数参数：将参数的每个值转换为固定长度为32bytes的十六进制字符串。如果有多个参数，则串联在一起。

如果用户将此4 + 32 * N字节字节代码传递给交易的数据字段。 EVM可以找到应执行的函数，然后将参数注入该函数。

停止使用Solidity的transfer()

以往是因为transfer()和send()是固定gas，用来避免call()的重入攻击，但是现在gas是可变的，这种固定gas的操作就不安全了。

使用检查-生效-交互(checks-effects-interactions)来避免call的重入攻击

使用工厂提高智能合约安全性

工厂模式看成是一种深入防守的托管方式

托管背后的理念是，不同的资金必须分开，以确保合约能够始终覆盖所有的欠款。 要想做好托管，最简单的方法之一就是将资金完全分离到不同的智能合约中。

使用工厂模式的一个主要缺点是，它的Gas 较高。

Solidity 优化

Solidity 怎样写出最节省Gas的智能合约

  1. 使用短路模式排序Solidity操作

    它将低gas成本的操作放在前面，高gas成本的操作放在后面，这样如果前面的低成本操作可行，就可以跳过（短路）后面的高成本以太坊虚拟机操作了

  2. 删减不必要的Solidity库

  3. 精确声明Solidity合约函数的可见性

    https://yeetsai.com/blog/2018/01/07/solidity-external-public-best-practices/

    通过显式地标记函数为外部函数（External），可以强制将函数参数的存储位置设置为calldata，这会节约每次函数执行时所需的以太坊gas成本

  4. 使用适合的数据类型

    • 在任何可以使用uint类型的情况下，不要使用string类型

    • 存储一个uint256要比存储一个uint8的gas成本低，因为每次存储都是32字节的，只存一个uint8还要从256进行缩小，但是如果是多个uint8能组成一个uint256，那比存多个256gas便宜

    • 当可以使用bytes类型时，不要在solidity合约种使用byte[]类型

    • 如果bytes的长度有可以预计的上限，那么尽可能改用bytes1~bytes32这些具有固定长度的solidity类型

    • bytes32所需的gas成本要低于string类型

  5. 避免Solidity智能合约中的死代码

  6. 避免使用不必要的条件判断

  7. 避免在循环中执行gas成本高的操作

  8. 避免使用常量结果的循环

  9. 合并循环

  10. 避免循环中的重复计算

  11. 去除循环中的比较运算

控制 gas 成本

  • 不要存储不必要的数据

  • 将多个小变量打包到单个字中

  • 仅将默克尔根存储为状态

  • 潜在的无限迭代

  • 链外计算(提示)

  • 使用提款模式

编写 O(1) 复杂度的可迭代映射

O(1) 复杂度: 表示即便数量增加，gas 成本也会保持一样。

比如从数组改成链表存储

减少智能合约的 gas 消耗的8种方法

  1. 首选数据类型：尽量使用256位的变量，例如 uint256和bytes32

  2. 在合约的字节码中存储值：constant， immutable

  3. 通过SOLC编译器将变量打包到单个插槽中：多个变量凑成一个插槽

  4. 通过汇编将变量打包到单个插槽中

    function encode(uint64 _a, uint64 _b, uint64 _c, uint64 _d) internal pure returns (bytes32 x) {
    assembly {
        let y := 0
        mstore(0x20, _d)
        mstore(0x18, _c)
        mstore(0x10, _b)
        mstore(0x8, _a)
        x := mload(0x20)
    }
}
function decode(bytes32 x) internal pure returns (uint64 a, uint64 b, uint64 c, uint64 d) {
    assembly {
        d := x
        mstore(0x18, x)
        a := mload(0)
        mstore(0x10, x)
        b := mload(0)
        mstore(0x8, x)
        c := mload(0)
    }
}

  5. 连接函数参数

    pragma solidity ^0.4.21;
contract bitCompaction {
  function oldExam(uint64 a, uint64 b, uint64 c, uint64 d) public {
  }
  function newExam(uint256 packed) public {
  }
}
Old: func once(uint256 header, uint256 val...) x N
New: func batch(uint256 header, uint256[] val... x N)

  6. Merkle 证明可减少存储负载

    bytes32 public merkleRoot;

//Let a,...,h be the orange base blocks
function check
(
    bytes32 hash4,
    bytes32 hash12,
    uint256 a,
    uint32 b,
    bytes32 c,
    string d,
    string e,
    bool f,
    uint256 g,
    uint256 h
)
    public view returns (bool success)
{
    bytes32 hash3 = keccak256(abi.encodePacked(a, b, c, d, e, f, g, h));
    bytes32 hash34 = keccak256(abi.encodePacked(hash3, hash4));
    require(keccak256(abi.encodePacked(hash12, hash34)) == merkleRoot, "Wrong Element");

    return true;
}

  7. 无状态合约

    正常的合约

    contract DataStore {
    mapping(address => mapping(bytes32 => string)) public store;
    
    event Save(address indexed from, bytes32 indexed key, string value);
    
    function save(bytes32 key, string value) {
        store[msg.sender][key] = value;
        Save(msg.sender, key, value);
    }
}

    无状态合约

    contract DataStore {
    function save(bytes32 key, string value) {}
}

    在 Etherscan 上查看此交易，向下滚动到输入数据，然后单击转换为 Ascii 按钮。我们的数据存在于交易的输入中。

    https://etherscan.io/tx/0xc9fdf51d30e4f9940c57a917a65da5e4ff1e4018283b8e62aa13d2dcea0d9b6b

  8. 在IPFS上存储数据

如何减少字节码大小及节省 gas

  1. 修饰器是内联函数，多次内联可能会超过合约的最大限制24KB，将内联函数的内部代码提取出来改成内部函数

    modifier onlyAuthorized() {
        bool isOwner = msg.sender == IOwnable(address(securityToken)).owner();
        require(isOwner ||
            securityToken.isModule(msg.sender, DATA_KEY) ||
            securityToken.checkPermission(msg.sender, address(this), MANAGEDATA),
            "Unauthorized"
        );
        _;
    }
//改写成
modifier onlyAuthorized() {
        _isAuthorized();
        _;
    }

function _isAuthorized() internal view {require(msg.sender == address(securityToken) ||
        msg.sender == IOwnable(address(securityToken)).owner() ||
        securityToken.checkPermission(msg.sender, address(this), MANAGEDATA) ||
        securityToken.isModule(msg.sender, DATA_KEY),
        "Unauthorized"
    );
}

  2. 布尔类型使用8位，而你只需要1位 ，用uint256存储256个布尔值，采用位移的方式

  3. 当你调用库的公共（public）函数时，该函数的字节码不会包含在合约内，因此可以把一些复杂的逻辑放在库中，这样减小合约的大小。不过你得清楚，调用库会花费一些gas和使用一些字节码。对库的调用是通过委托调用（delegate call）的方式进行的，这意味着库可以访问合约拥有的数据，并且具有相同的权限。因此对于简单任务不值得这样做。

  4. 无需使用默认值初始化变量

  5. 使用简短的错误原因字符串，使用error关键字更省gas

  6. 避免重复检查

  7. 单行交换变量

    (hello, world) = (world, hello)

  8. 使用事件存储链上不需要的数据

  9. 适当的使用优化(optimizer)

  10. 更少调用函数可能更好

  11. 调用内部函数更便宜

    在智能合约内部，调用内部（internal）函数比调用公共（public）函数要便宜，因为当你调用公共函数时，所有参数都会再次复制到内存中并传递给该函数。相比之下，当你调用内部函数时，将传递这些参数的引用，并且它们不会再次复制到内存中。这样可以节省一些 gas ，尤其是在参数较大时如此。

  12. 使用代理模式进行大规模部署

一些简单的 Gas 优化基础

  1. 升级 Solidity 版本

  2. 放弃 Counters.sol

  3. 避免将参数复制到内存

    对于某些类型的参数，如字符串或者数组，Solidity 会强制指定存储位置(memory或calldata )。这里用calldata会便宜的多，所以你会希望尽可能多的使用它，而memory只在你需要修改参数时才用（因为calldata会让它们只读）

当使用任何一种计数器（如_tokenId），从1开始而不是从0开始，会让第一次 mint 便宜一些。通常，写入没有值的槽比写入有值的槽更贵。

此外，整数递增，++i(返回上一次的值，然后再加1)比i++(加1，然后返回新的值)更便宜。如果你仅仅需要一个计数器而不需要它的返回值，你可能会更想要第一种。

除法，Solidity 插入了一个检查，确保没有被0除。如果你可以确定除数不为0，你可以使用汇编来执行操作，这样可以节省一些额外的gas

标记为payable的函数会比其他函数调用时便宜

"Stack Too Deep（堆栈太深）" 解决方案

// SPDX-License-Identifier: MIT
pragma solidity 0.7.1;

contract StackTooDeepTest1 {
    function addUints(
        uint256 a,uint256 b,uint256 c,uint256 d,uint256 e,uint256 f,uint256 g,uint256 h,uint256 i
    ) external pure returns(uint256) {

        return a+b+c+d+e+f+g+h+i;
    }
}

  1. 使用更少的变量

  2. 利用函数

    使用内部函数解决

    // SPDX-License-Identifier: MIT
pragma solidity 0.7.1;

contract StackTooDeepTest1 {
   function addUints(
        uint256 a,uint256 b,uint256 c,uint256 d,uint256 e,uint256 f,uint256 g,uint256 h,uint256 i
    ) external pure returns(uint256) {

        return _addThreeUints(a,b,c) + _addThreeUints(d,e,f) + _addThreeUints(g,h,i);
    }

    function _addThreeUints(uint256 a, uint256 b, uint256 c) private pure returns(uint256) {
        return a+b+c;
    }
}

  3. 代码块作用域范围

    // SPDX-License-Identifier: MIT
pragma solidity 0.7.1;

contract StackTooDeepTest2 {
    function addUints(
        uint256 a,uint256 b,uint256 c,uint256 d,uint256 e,uint256 f,uint256 g,uint256 h,uint256 i
    ) external pure returns(uint256) {

        uint256 result = 0;

        {
            result = a+b+c+d+e;
        }

        {
            result = result+f+g+h+i;
        }

        return result;
    }
}

  4. 利用结构体

    // SPDX-License-Identifier: MIT
pragma solidity 0.7.1;
pragma experimental ABIEncoderV2;

contract StackTooDeepTest3 {
    struct UintPair {
        uint256 value1;
        uint256 value2;
    }

    function addUints(
        UintPair memory a, UintPair memory b, UintPair memory c, UintPair memory d, uint256 e
    ) external pure returns(uint256) {

        return a.value1+a.value2+b.value1+b.value2+c.value1+c.value2+d.value1+d.value2+e;
    }
}

  5. 一些黑技巧

    // SPDX-License-Identifier: MIT
pragma solidity 0.7.1;

contract StackTooDeepTest4 {
    function addUints(
        uint256 /*a*/,uint256 /*b*/,uint256 c,uint256 d,uint256 e,uint256 f,uint256 g,uint256 h,uint256 i
    ) external pure returns(uint256) {
      return _fromUint(msg.data)+c+d+e+f+g+h+i;
    }

    function _fromUint(bytes memory data) internal pure returns(uint256 value) {
        uint256 value1;
        uint256 value2;

        assembly {
            value1 := mload(add(data, 36))
            value2 := mload(add(data, 68))
            value  := add(value1, value2)
        }
    }
}

    智能合约Gas 优化的几个技术

    • 交易Gas：用户每次与智能合约交互时支付的 Gas 量。实现 Gas 高效的函数，必须尽可能地减少Gas消耗。

    • 部署Gas ：每次部署智能合约时，需要支付的Gas量。部署智能合约通常只发生一次，尽管如此，仍然可以节省 Gas 也是很有趣的。

  • 尽量减少链上数据（使用事件、IPFS、无状态合约、merkle证明）。

  • 最小化链上操作（字符串、返回存储值、循环、本地存储、批处理）

  • 内存位置（calldata、栈、内存、存储）。

    以太坊有4个内存位置，从最便宜的到最贵的：calldata，栈，内存和存储。如果使用得当，你将节省大量的交易 Gas。

    • Calldata ：只适用于输入参数且参数是外部函数的引用数据类型（数组，字符串 ...）。Calldata参数是只读的，如果你有一些需要传递给函数的引用类型，总是考虑使用calldata，因为它是最便宜的。

    • 栈：只对方法中定义的值类型数据有效。

    • 内存：内存是易丢失的RAM，在EVM终止运行的时候会被移除。你可以用它来存储引用数据类型，它比存储更便宜。当向其他函数传递参数，或在你的函数中声明临时变量时，除非你严格需要使用存储，否则应该总是使用内存。

    • 存储：是最昂贵的存储位置。存储数据在区块链上持久存在，正如这个列表的第一个元素所说，应该总是尽量减少链上数据

  • 变量顺序

  • 首选的数据类型

  • 库（嵌入式库，独立部署库合约）。

  • 最小代理（Minimal Proxy）

  • 构造函数

  • 合约大小（消息、修改器、函数）。

  • Solidity编译器优化器

避免区块Gas限制导致问题

（2023年3月7日）现在每个区块的目标气体限制为1500 万气体，但大小可以根据网络需求而变化，最高可达3000 万气体。 通过调整区块大小和基本费用，网络通常在1500 万气体时达到平衡。 如果区块gas 高于15M 阈值，则提高下一个区块的基本费用。 同样，如果区块gas 低于15M 阈值，则下一个区块的基本费用会降低。

当合约中存在依赖时间、依赖数据大小（如数组长度）的循环时，都可能会有潜在的漏洞。

如何缩减合约以规避合约大小限制

引入这一限制是为了防止拒绝服务（DOS）攻击。

  • 把你的合约分开

  • 使用库

  • 使用代理

  • 删除一些函数

  • 避免额外的变量

  • 缩短错误提示信息

  • 在优化器中考虑一个低的运行值

  • 避免向函数传递结构体

  • 声明函数和变量的正确可见性

  • 删除函数修改器

ERC20-Permit

之前方法：

  1. 用户提交token.approve(myContract.address, amount)交易。

  2. 等待交易确认。

  3. 用户提交第二个 myContract.doSomething()交易，该交易内部使用 token.transferFrom。

现在：

  1. 用户进行授权签名：签名信息signature=(myContract.address，amount)。

  2. 用户向 myContract.doSomething(signature)提交签名。

  3. myContract使用 token.permit增加配额，并调用 token.transferFrom 获取代币。

Subscribe to 0x3c
Receive the latest updates directly to your inbox.
Nft graphic
Mint this entry as an NFT to add it to your collection.
Verification
This entry has been permanently stored onchain and signed by its creator.
Arweave Transaction
5Suun1lGbfF0AcJ…0F55Xqs2wQZGzXY
Author Address
0xF3f29F8ED882650…9cc652abCE822E8
Content Digest
YgbQ46gA-1xKCPz…2YSBBcWJG4HYYkY
More from 0x3c
View All

Skeleton

Skeleton

Skeleton