【翻译】编写可升级的智能合约

Shannon
更新于 2021-01-09 11:32
阅读 1244

当使用OpenZeppelin Upgrades编写可升级合约时，有一些在编写Solidity代码时需要记住一些注意事项。

# 编写可升级的智能合约

[原文链接](https://docs.openzeppelin.com/upgrades-plugins/1.x/writing-upgradeable)

当使用OpenZeppelin Upgrades编写可升级合约时，有一些在编写Solidity代码时需要记住一些注意事项。

值得一提的是，这些限制源于以太坊虚拟机的工作方式，并且适用于所有使用可升级合约的项目，而不仅仅是OpenZeppelin Upgrades。

## 初始化器（Initializers）
在编写Solidity合约使用OpenZeppelin Upgrades，无需任何修改，只需要修改构造函数。由于基于代理的可升级性系统的要求，可升级合约中不能使用构造函数。要了解这个限制背后的原因，请查看[代理](https://docs.openzeppelin.com/upgrades-plugins/1.x/proxies#the-constructor-caveat)。

这意味着，当使用OpenZeppelin可升级的合约时，您需要将其构造函数改为一个常规函数，通常命名为`initialize`，在那里执行所有的初始化逻辑。

```js
// NOTE: Do not use this code snippet, it's incomplete and has a critical vulnerability!

pragma solidity ^0.6.0;

contract MyContract {
    uint256 public x;

function initialize(uint256 _x) public {
        x = _x;
    }
}
```

然而，虽然Solidity确保一个构造函数`constructor`在合约的生命周期内只被调用一次，但一个普通函数可以被多次调用。为了防止一个合约被多次初始化，你需要添加一个检查来确保初始化函数只被调用一次。

```js
// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

contract MyContract {
    uint256 public x;
    bool private initialized;

function initialize(uint256 _x) public {
        require(!initialized, "Contract instance has already been initialized");
        initialized = true;
        x = _x;
    }
}
```

由于这种模式在编写可升级合约时非常常见，OpenZeppelin Upgrades提供了一个`Initializable`基础合约，它有一个`initializer` modifier来处理这个问题。

```js
// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import "@openzeppelin/upgrades/contracts/Initializable.sol";

contract MyContract is Initializable {
    uint256 public x;

function initialize(uint256 _x) public initializer {
        x = _x;
    }
}
```

构造函数`constructor`和普通函数的另一个区别是，Solidity负责自动调用一个合约的所有基类的构造函数。在编写初始化器initializer时，你需要特别注意手动调用所有父合约的初始化器initializer。

```js
// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import "@openzeppelin/upgrades/contracts/Initializable.sol";

contract BaseContract is Initializable {
    uint256 public y;

function initialize() public initializer {
        y = 42;
    }
}

contract MyContract is BaseContract {
    uint256 public x;

function initialize(uint256 _x) public initializer {
        BaseContract.initialize(); // Do not forget this call!
        x = _x;
    }
}

```

### 使用可升级的智能合约库

请记住，这个限制不仅会影响你的合约，还会影响你从库中导入的合约。例如考虑OpenZeppelin合约中的[`ERC20`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.2.0/contracts/token/ERC20/ERC20.sol)：该合约在其构造函数中初始化了token的名称、符号和小数位数。

```js
// @openzeppelin/contracts/token/ERC20/ERC20.sol
pragma solidity ^0.6.0;

...

contract ERC20 is Context, IERC20 {

...

string private _name;
    string private _symbol;
    uint8 private _decimals;

constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

...
}
```

这意味着你不应该在你的OpenZeppelin Upgrades项目中使用这些合约。相反，请确保使用`@openzeppelin/contracts-upgradeable`，它是OpenZeppelin合约的官方分支，已经被修改为使用初始化器而不是构造函数。看看在`@openzeppelin/contracts-upgradeable`中的[ERC20Upgradeable](https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/v3.2.0/contracts/token/ERC20/ERC20Upgradeable.sol)是什么样子：

```js
// @openzeppelin/contracts-upgradeable/contracts/token/ERC20/ERC20Upgradeable.sol
pragma solidity ^0.6.0;
  ...
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable {
  ...
    string private _name;
    string private _symbol;
    uint8 private _decimals;

function __ERC20_init(string memory name, string memory symbol) internal initializer {
        __Context_init_unchained();
        __ERC20_init_unchained(name, symbol);
    }

function __ERC20_init_unchained(string memory name, string memory symbol) internal initializer {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }
  ...
}
```

无论是使用OpenZeppelin合约还是其他智能合约库，都要确保软件包被设置为处理可升级合约。

在合约中了解更多关于OpenZeppelin合约可升级的信息： [Contracts: Using with Upgrades](https://docs.openzeppelin.com/contracts/3.x/upgradeable)。

### 避免在字段声明中使用初始值
Solidity允许在合约中声明字段时为其定义初始值。

```js
contract MyContract {
    uint256 public hasInitialValue = 42; // equivalent to setting in the constructor
}
```

这相当于在构造函数中设置了这些值，因此，对于可升级的合约是无效的。请确保所有初始值都在如下所示初始化函数中设置；否则，任何可升级的实例都不会设置这些字段。

```js
contract MyContract is Initializable {
    uint256 public hasInitialValue;

function initialize() public initializer {
        hasInitialValue = 42; // set initial value in initializer
    }
}
```

**注意** 定义*常量*状态变量还是可以的，因为编译器并没有[为这些变量预留存储槽](https://solidity.readthedocs.io/en/latest/contracts.html#constant-state-variables)，每出现一次就会被相应的常量表达式所替代。所以下面的内容在OpenZeppelin Upgrades中仍然可以使用：

```js
contract MyContract {
    uint256 public constant hasInitialValue = 42; // define as constant
}
```

## 从合约代码中创建新实例
当从合约代码中创建一个新的合约实例时，这些创建直接由Solidity处理，而不是由OpenZeppelin Upgrades处理，这意味着这些合约将无法升级。

例如，在下面的例子中，即使MyContract被部署为可升级，创建的`token`合约也是不可升级的:

```js
// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import "@openzeppelin/upgrades/contracts/Initializable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyContract is Initializable {
    ERC20 public token;

function initialize() public initializer {
        token = new ERC20("Test", "TST"); // This contract will not be upgradeable
    }
}
```

如果你希望`ERC20`实例可以升级，最简单的实现方式就是直接地接受该合约的实例作为参数，并在创建后接管它：

```js
// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import "@openzeppelin/contracts-upgradeable/contracts/proxy/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol";

contract MyContract is Initializable {
    IERC20 public token;

function initialize(IERC20Upgradeable _token) public initializer {
        token = _token;
    }
}
```

## 潜在的不安全操作
在使用可升级的智能合约时，你将始终与（代理）合约实例进行交互，而不是底层逻辑合约。然而我们却无法阻止恶意行为者直接向逻辑合约发送交易。这不会构成威胁，因为逻辑合约状态的任何变化都不会影响你的（代理）合约实例，因为你的项目中从未使用过逻辑合约的存储。

然而，有一个例外。如果对逻辑合约的直接调用触发了自毁操作`selfdestruct`，那么逻辑合约就会被销毁，你的所有合约实例最终都会将所有的调用委托给一个地址，而不会有任何代码。这会破坏你项目中的所有合约实例。

如果逻辑合约中包含委托调用`delegatecall`操作，也可以达到类似的效果。如果可以将`delegatecall`变成一个包含自毁的恶意合约，那么调用合约将被破坏。

因此，在你的合约中不允许使用`selfdestruct`或`delegatecall`。

## 修改你的合约
在编写新版本的合约时，无论是由于新功能还是bug修复，都有一个额外的限制需要遵守：你不能改变合约状态变量的声明顺序，也不能改变它们的类型。你可以通过了解 [Proxies](https://docs.openzeppelin.com/upgrades-plugins/1.x/proxies)来阅读更多关于这个限制背后的原因。

**警告** 违反这些存储布局限制中的任何一项，都会导致升级版的合约的存储值被混淆，并可能导致你的应用程序出现关键错误。
这意味着，如果初始合约看起来像这样：

```js
contract MyContract {
    uint256 private x;
    string private y;
}
```

那么不可以修改合约变量类型:

```solidity
contract MyContract {
    string private x;
    string private y;
}
```

也无法改变变量的声明顺序:

```solidity
contract MyContract {
    string private y;
    uint256 private x;
}
```

不能在现有变量之前引入新的变量:

```solidity
contract MyContract {
    bytes private a;
    uint256 private x;
    string private y;
}
```

也不能删除现有变量:

```solidity
contract MyContract {
    string private y;
}
```

如果需要引入新的变量，请确保添加到原有变量的后面:

```solidity
contract MyContract {
    uint256 private x;
    string private y;
    bytes private z;
}
```

注意，如果重命名一个变量，那么在升级后，它将保持与之前相同的值。如果新变量和旧变量的语义相同，那么这可能是我们所希望的行为:

```solidity
contract MyContract {
    uint256 private x;
    string private z; // starts with the value from `y`
}
```

而如果你在合约的最后删除了一个变量，请注意存储不会被清除。随后的更新中如果增加一个新的变量，会导致该变量从被删除的变量中读取遗留的值：

```solidity
contract MyContract {
    uint256 private x;
}
```

升级到:

```solidity
contract MyContract {
    uint256 private x;
    string private z; // starts with the value from `y`
}
```

注意，你也可能会因为改变合约的父合约而无意中改变合约的存储变量。例如，如果你有以下合约：

```solidity
contract A {
    uint256 a;
}

contract B {
    uint256 b;
}

contract MyContract is A, B {}
```

然后通过调换基础合约的声明顺序或引入新的基础合约来修改`MyContract`，将改变变量的实际存储方式：

```solidity
contract MyContract is B, A {}
```

如果集成合约有任何自己的变量，你也不能在基础合约中添加新的变量。鉴于以下情况：

```solidity
contract Base {
    uint256 base1;
}

contract Child is Base {
    uint256 child;
}
```

如果修改`Base`，增加一个额外的变量：

```solidity
contract Base {
    uint256 base1;
    uint256 base2;
}
```

然后，变量`base2`将被分配到上一个版本中那个`child`的槽位。一个变通的办法是在基础合约上声明未使用的变量，你可能会在未来想要扩展，作为 "保留 "这些槽位的一种手段。请注意，这个技巧不会增加gas使用量。

编写可升级的智能合约

原文链接

当使用OpenZeppelin Upgrades编写可升级合约时，有一些在编写Solidity代码时需要记住一些注意事项。

值得一提的是，这些限制源于以太坊虚拟机的工作方式，并且适用于所有使用可升级合约的项目，而不仅仅是OpenZeppelin Upgrades。

初始化器（Initializers）

在编写Solidity合约使用OpenZeppelin Upgrades，无需任何修改，只需要修改构造函数。由于基于代理的可升级性系统的要求，可升级合约中不能使用构造函数。要了解这个限制背后的原因，请查看代理。

这意味着，当使用OpenZeppelin可升级的合约时，您需要将其构造函数改为一个常规函数，通常命名为initialize，在那里执行所有的初始化逻辑。

// NOTE: Do not use this code snippet, it's incomplete and has a critical vulnerability!

pragma solidity ^0.6.0;

contract MyContract {
    uint256 public x;

    function initialize(uint256 _x) public {
        x = _x;
    }
}

然而，虽然Solidity确保一个构造函数constructor在合约的生命周期内只被调用一次，但一个普通函数可以被多次调用。为了防止一个合约被多次初始化，你需要添加一个检查来确保初始化函数只被调用一次。

// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

contract MyContract {
    uint256 public x;
    bool private initialized;

    function initialize(uint256 _x) public {
        require(!initialized, "Contract instance has already been initialized");
        initialized = true;
        x = _x;
    }
}

由于这种模式在编写可升级合约时非常常见，OpenZeppelin Upgrades提供了一个Initializable基础合约，它有一个initializer modifier来处理这个问题。

// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import "@openzeppelin/upgrades/contracts/Initializable.sol";

contract MyContract is Initializable {
    uint256 public x;

    function initialize(uint256 _x) public initializer {
        x = _x;
    }
}

构造函数constructor和普通函数的另一个区别是，Solidity负责自动调用一个合约的所有基类的构造函数。在编写初始化器initializer时，你需要特别注意手动调用所有父合约的初始化器initializer。

// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import "@openzeppelin/upgrades/contracts/Initializable.sol";

contract BaseContract is Initializable {
    uint256 public y;

    function initialize() public initializer {
        y = 42;
    }
}

contract MyContract is BaseContract {
    uint256 public x;

    function initialize(uint256 _x) public initializer {
        BaseContract.initialize(); // Do not forget this call!
        x = _x;
    }
}

使用可升级的智能合约库

请记住，这个限制不仅会影响你的合约，还会影响你从库中导入的合约。例如考虑OpenZeppelin合约中的ERC20：该合约在其构造函数中初始化了token的名称、符号和小数位数。

// @openzeppelin/contracts/token/ERC20/ERC20.sol
pragma solidity ^0.6.0;

  ...

contract ERC20 is Context, IERC20 {

  ...

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

  ...
}

这意味着你不应该在你的OpenZeppelin Upgrades项目中使用这些合约。相反，请确保使用@openzeppelin/contracts-upgradeable，它是OpenZeppelin合约的官方分支，已经被修改为使用初始化器而不是构造函数。看看在@openzeppelin/contracts-upgradeable中的ERC20Upgradeable是什么样子：

// @openzeppelin/contracts-upgradeable/contracts/token/ERC20/ERC20Upgradeable.sol
pragma solidity ^0.6.0;
  ...
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable {
  ...
    string private _name;
    string private _symbol;
    uint8 private _decimals;

    function __ERC20_init(string memory name, string memory symbol) internal initializer {
        __Context_init_unchained();
        __ERC20_init_unchained(name, symbol);
    }

    function __ERC20_init_unchained(string memory name, string memory symbol) internal initializer {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }
  ...
}

无论是使用OpenZeppelin合约还是其他智能合约库，都要确保软件包被设置为处理可升级合约。

在合约中了解更多关于OpenZeppelin合约可升级的信息： Contracts: Using with Upgrades。

避免在字段声明中使用初始值

Solidity允许在合约中声明字段时为其定义初始值。

contract MyContract {
    uint256 public hasInitialValue = 42; // equivalent to setting in the constructor
}

contract MyContract is Initializable {
    uint256 public hasInitialValue;

    function initialize() public initializer {
        hasInitialValue = 42; // set initial value in initializer
    }
}

注意定义常量状态变量还是可以的，因为编译器并没有为这些变量预留存储槽，每出现一次就会被相应的常量表达式所替代。所以下面的内容在OpenZeppelin Upgrades中仍然可以使用：

contract MyContract {
    uint256 public constant hasInitialValue = 42; // define as constant
}

从合约代码中创建新实例

当从合约代码中创建一个新的合约实例时，这些创建直接由Solidity处理，而不是由OpenZeppelin Upgrades处理，这意味着这些合约将无法升级。

例如，在下面的例子中，即使MyContract被部署为可升级，创建的token合约也是不可升级的:

// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import "@openzeppelin/upgrades/contracts/Initializable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyContract is Initializable {
    ERC20 public token;

    function initialize() public initializer {
        token = new ERC20("Test", "TST"); // This contract will not be upgradeable
    }
}

如果你希望ERC20实例可以升级，最简单的实现方式就是直接地接受该合约的实例作为参数，并在创建后接管它：

// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import "@openzeppelin/contracts-upgradeable/contracts/proxy/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol";

contract MyContract is Initializable {
    IERC20 public token;

    function initialize(IERC20Upgradeable _token) public initializer {
        token = _token;
    }
}

潜在的不安全操作

在使用可升级的智能合约时，你将始终与（代理）合约实例进行交互，而不是底层逻辑合约。然而我们却无法阻止恶意行为者直接向逻辑合约发送交易。这不会构成威胁，因为逻辑合约状态的任何变化都不会影响你的（代理）合约实例，因为你的项目中从未使用过逻辑合约的存储。

然而，有一个例外。如果对逻辑合约的直接调用触发了自毁操作selfdestruct，那么逻辑合约就会被销毁，你的所有合约实例最终都会将所有的调用委托给一个地址，而不会有任何代码。这会破坏你项目中的所有合约实例。

如果逻辑合约中包含委托调用delegatecall操作，也可以达到类似的效果。如果可以将delegatecall变成一个包含自毁的恶意合约，那么调用合约将被破坏。

因此，在你的合约中不允许使用selfdestruct或delegatecall。

修改你的合约

在编写新版本的合约时，无论是由于新功能还是bug修复，都有一个额外的限制需要遵守：你不能改变合约状态变量的声明顺序，也不能改变它们的类型。你可以通过了解 Proxies来阅读更多关于这个限制背后的原因。

警告违反这些存储布局限制中的任何一项，都会导致升级版的合约的存储值被混淆，并可能导致你的应用程序出现关键错误。这意味着，如果初始合约看起来像这样：

contract MyContract {
    uint256 private x;
    string private y;
}

那么不可以修改合约变量类型:

contract MyContract {
    string private x;
    string private y;
}

也无法改变变量的声明顺序:

contract MyContract {
    string private y;
    uint256 private x;
}

不能在现有变量之前引入新的变量:

contract MyContract {
    bytes private a;
    uint256 private x;
    string private y;
}

也不能删除现有变量:

contract MyContract {
    string private y;
}

如果需要引入新的变量，请确保添加到原有变量的后面:

contract MyContract {
    uint256 private x;
    string private y;
    bytes private z;
}

注意，如果重命名一个变量，那么在升级后，它将保持与之前相同的值。如果新变量和旧变量的语义相同，那么这可能是我们所希望的行为:

contract MyContract {
    uint256 private x;
    string private z; // starts with the value from `y`
}

contract MyContract {
    uint256 private x;
}

升级到:

contract MyContract {
    uint256 private x;
    string private z; // starts with the value from `y`
}

注意，你也可能会因为改变合约的父合约而无意中改变合约的存储变量。例如，如果你有以下合约：

contract A {
    uint256 a;
}

contract B {
    uint256 b;
}

contract MyContract is A, B {}

然后通过调换基础合约的声明顺序或引入新的基础合约来修改MyContract，将改变变量的实际存储方式：

contract MyContract is B, A {}

如果集成合约有任何自己的变量，你也不能在基础合约中添加新的变量。鉴于以下情况：

contract Base {
    uint256 base1;
}

contract Child is Base {
    uint256 child;
}

如果修改Base，增加一个额外的变量：

contract Base {
    uint256 base1;
    uint256 base2;
}

然后，变量base2将被分配到上一个版本中那个child的槽位。一个变通的办法是在基础合约上声明未使用的变量，你可能会在未来想要扩展，作为 "保留 "这些槽位的一种手段。请注意，这个技巧不会增加gas使用量。

学分: 105
分类: Solidity
标签: Solidity 合约升级

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

【翻译】编写可升级的智能合约

编写可升级的智能合约

初始化器（Initializers）

使用可升级的智能合约库

避免在字段声明中使用初始值

从合约代码中创建新实例

潜在的不安全操作

修改你的合约

0 条评论

文章目录