小丑西瓜9

这个屌丝很懒，什么也没留下！

热门标签

Solidity—— call、staticcall和delegatecall用法介绍_solidity staticcall

作者：小丑西瓜9 | 2024-03-02 12:08:49

踩

solidity staticcall

在一个智能合约中调用另外一个外部智能合约的函数，我们可以通过接口 interface 的方式进行调用。另外，还有一种比较底层的调用方法，就是使用call、staticcall和delegatecall函数。它们是一种低级、底层的调用方式，具有更大的灵活性。我们将分别进行讲解。

一、底层调用 call

1、函数语法

(bool success, bytes memory result) = address(contractAddress).call{value: valueToSend}(data);

其中的返回值的含义如下：

success：指示调用外部函数是否成功。

result：调用的外部函数的返回值。

其中的参数的含义如下：

contractAddress：要调用的外部合约的地址。

valueToSend：发送到外部合约的 ETH 数量，它的单位是 wei。这是一个可选参数，如果无需发送 ETH，就可以选择忽略这个参数。

data：发送到外部合约的数据。它是对外部函数签名和参数进行编码，而生成的字节数组。

比如，我们要调用一个外部合约的函数 functionName(uint256)，那么就需要使用 abi 对函数签名和参数进行编码。

编码方法如下：

abi.encodeWithSignature("functionName(uint256)", parameter);

2、函数示例

我们先准备一个被调用的合约Receive.sol，合约中定义了一个函数 foo()，且该函数能够接受ETH。另外，这个合约还定义了 receive() 和constructor()函数，使之具有接收 ETH 的能力。call在合约Caller.sol的使用场景如下：

只调用外部函数
只向外部合约发送ETH
调用外部函数并发送ETH

调用者合约代码：


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
 
contract Caller{
 
    constructor() payable {}
    // 1只调用外部合约的函数
    // 参数 contractAddress 是被调用合约的地址
    function callExternalFunc(address contractAddress) external returns(bool, bytes memory) {
 
        // 对函数签名和参数进行编码
        bytes memory data = abi.encodeWithSignature("foo(uint256)", 8);
 
        // 调用外部合约函数
        return contractAddress.call(data);
    }
 
    // 2只向外部合约发送ETH
    // 参数 contractAddress 是被调用合约的地址
    function callExternal(address contractAddress) external returns(bool, bytes memory) {
 
        // 调用外部合约函数
        return contractAddress.call{value: 1 ether}("");
    }
 
    // 3调用外部合约的函数及发送ETH
    // 参数 contractAddress 是被调用合约的地址
    function callExternalFuncAndETH(address contractAddress) external returns(bool, bytes memory) {
 
        // 对函数签名和参数进行编码
        bytes memory data = abi.encodeWithSignature("foo(uint256)", 8);
 
        // 调用外部合约函数
        return contractAddress.call{value: 1 ether}(data);
    }
}

被调用者合约代码：


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
 
contract Receive{
    uint256 public value;
 
    //部署时可以接受ETH
    constructor() payable {}
 
    function foo(uint256 _value) external payable {
        value = _value;
    }
 
    //合约账户可以接受ETH
    receive() external payable { }
 
}

3、部署测试

我们通过remix来执行本地部署和测试，这里只对【场景三】进行模拟测试：

需要先部署Receive.sol得到合约地址：0xb27A31f1b0AF2946B7F582768f03239b1eC07c2c，我们可以看到当前合约账户的ETH余额为0

后部署Receive.sol，并在部署时存入5个ETH，稍后用于发送，得到合约地址为：0xcD6a42782d230D7c13A74ddec5dD140e55499Df9

可以看到当前合约账户余额确定为：5ETH

接下来我们需要执行函数callExternalFuncAndETH()，参数为Receive.sol合约地址，发起对外部合约函数的调用，我们可以观察到被调用者合约的状态变量变化情况如下

调用者合约状态变量变化情况如下：

验证通过。

二、静态调用 staticcall

在 Solidity 中，staticcall 是一个用于在智能合约中调用外部合约函数的一种方式。staticcall 是一个低级别的操作，它允许一个合约在调用外部合约函数时，仅限于读取外部合约的数据而不修改它的状态。也就是说，staticcall 的只能调用外部合约的视图函数和纯函数，即函数的状态可变性为 view 或 pure 函数。

1、staticcall 实现原理

staticcall 是 EVM 中的一条指令，指令代码是 0xfa。当执行 staticcall 调用一个外部合约的函数时，它会将 EVM 解释器的状态 readonly 置为 true。


func (evm *EVM) StaticCall(....) (ret []byte, leftOverGas uint64, err error) {
  .....
  ret, err = evm.interpreter.Run(contract, input, true) /*readonly=true*/
  ....
}

当 EVM 执行外部合约的函数时，如果解释器的状态 readonly 为 true，那么该函数就不能执行状态变量存储指令 opSstore。也就是说，该外部合约的函数不能改变合约状态。


func opSstore(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
  ....
  if interpreter.readOnly {
    return nil, ErrWriteProtection
  }
  ....
}

2、函数语法

(bool success, bytes memory result) = address(contractAddress).staticcall(data);

3、函数示例

代码示例：


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
 
// 被调用合约
contract StaticCall {
    //被调用函数
    function bar() external pure returns(uint256) {
        return 1;
    }
}
 
// 调用者合约
contract StaticCaller{
    //staticcall
    // 参数 contractAddress 是被调用合约的地址
    function staticCallExternal(address contractAddress) external view returns(bool, bytes memory) {
        // 对函数签名和参数进行编码
        bytes memory data = abi.encodeWithSignature("bar()");
 
        // 静态调用外部合约函数
        return contractAddress.staticcall(data);
    }
}

4、部署测试

我们将上面的合约复制到 Remix，先进行编译。

编译后会有两个合约 StaticCall 和 StaticCaller，我们要首先部署被调用合约 StaticCall，然后再部署静态调用合约 StaticCaller。

我们将 StaticCall 合约的地址填写到 StaticCaller 的 staticCallExternal 参数位置，然后点击 call 按钮进行调用。

我们可以看到调用结果为 true，表示调用成功。而被调用合约 StaticCall 的函数 bar，返回了结果值 1。

三、委托调用 delegatecall

在 Solidity 中，delegatecall 是用于在智能合约中调用外部合约函数的一种方式。delegatecall 是一个低级别的操作，它具有一些独特的特性，通常用于实现可升级合约。

一个合约 A 使用 delegatecall 调用合约 B 的函数，那么会在合约 A 的上下文 Context 中执行合约 B 的函数代码，并将结果作用于合约 A 的状态变量和存储上。

我们可以看一下 delegatecall 和 call 对比，来理解两者的不同的工作方式。

1、delegatecall 和 call 对比

a. call 的工作方式

当外部调用者 A 通过合约 B ，使用 call 方式调用合约 C 的函数时，将会执行合约 C 的函数代码，该函数所处的上下文 Context 是合约 C 的上下文。这里的 Context 是指执行中的合约状态和存储环境。

这种调用方式，也就意味着，如果执行的函数改变了一些状态，最后的结果都会保存在合约 C 的状态变量和存储上。同时，执行函数中的 msg.sender 是合约 B 的地址，msg.value 也是合约 B 设定的数量。

b. delegatecall 的工作方式

当外部调用者 A 通过合约 B ，使用 delegatecall 方式调用合约 C 的函数时，将会执行合约 C 的函数代码，但该函数所处的上下文 Context 仍然是合约 B 的上下文。

也就意味着，如果执行的函数改变了状态，产生的结果都会保存在合约 B 的Context中。同时，执行函数中的 msg.sender 是合约 A 的地址，msg.value 也是合约 A 设定的数量。

从逻辑上理解，相当于合约B和合约C是一体，合约B负责存储数据，合约C负责处理业务逻辑，实现了对业务逻辑和数据存储的分离，正因为这一独特优势，对于需要升级合约的场景很有帮助，可以避免每次升级因迁移存储数据带来的高额gas消耗，只需要升级逻辑合约即可。

2、delegatecall 的使用场景

在智能合约开发中，delegatecall 主要用于以下两种场景：

a. 代理合约

实现代理合约是 delegatecall 最常见的用途。在这种模式下，智能合约的存储和逻辑可以实现分离。代理合约负责存储所有的状态变量（即：存储），逻辑合约负责实现所有业务逻辑（即：代码）。

代理合约会保存一个指向逻辑合约地址的变量，它会把所有的函数调用转发到逻辑合约上。如果业务逻辑升级的话，可以直接部署一个新的逻辑合约，代理合约只需更改指向逻辑合约的地址即可。所以，在 delegatecall 调用方式下，所有数据保存在代理合约中，所以，升级逻辑合约不会对原有数据造成影响。

b. 库函数重用

delegatecall 也被用于实现类似于传统编程中的库函数调用。通过 delegatecall，一个合约可以借用另一个合约的函数，就好像这些函数是在调用合约本身中定义的一样。这样，开发者可以创建通用的合约库，以减少重复代码，提高代码的复用性和合约的效率。

3、函数示例


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
 
// 被调用的智能合约
contract C  {
    // 整型状态变量
    uint256 public value = 0;
 
    /**
     * @dev 改变状态变量 value 的值
     * @param _value 新的变量值
     */
    function setValue(uint256 _value) external {
        value = _value;
    }
}
 
// 使用 delegatecall 方式调用 C 合约
contract B  {
    // 整型状态变量
    uint256 public value = 0;
 
    /**
     * @dev 使用 delegatecall 方式调用外部合约
     * @param contractAddress 外部合约地址
     * @param _value 新的变量值
     */
    function changeValue(address contractAddress, uint256 _value) 
        external returns(bool, bytes memory){
        // 对函数签名和参数进行编码
        bytes memory data = abi.encodeWithSignature("setValue(uint256)", _value);
 
        // 通过 delegatecall 调用外部合约函数
        return contractAddress.delegatecall(data);
    }
}

4、部署测试

我们要在 B 合约中使用 delegatecall 方式调用 C 合约的函数 setValue。

我们将上面的合约复制到 Remix，进行编译，然后分别部署 B 和 C 两个合约。并调用B合约的changeValue()函数。可以看到：

1. 点击 B 合约的函数 changeValue，在 contractAddress 中填写 C 合约地址，_value 中填入 2，然后点击 transact 执行函数。

2. 函数执行成功后，我们查看 B 合约的状态变量 value，发现它的值变成了 2 。

3. 我们再去查看 C 合约中的状态变量 value，发现它的值没有改变，依然是 0 。

所以，使用 delegatecall 方式执行的是 C 合约的代码，但改变的调用合约 B 的状态变量，合约 C 的上下文合约 B 的上下文。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/180412