【区块链安全 | 第十六篇】类型之值类型（三）

值类型

函数类型

函数类型是函数的类型。函数类型的变量可以通过函数进行赋值，函数类型的参数可以用来传递函数并返回函数。

函数类型有两种类型：内部函数和外部函数。

• 内部函数只能在当前合约内调用（更具体地说，在当前代码单元内调用，这也包括内部库函数和继承函数），因为它们无法在当前合约的上下文外执行。调用内部函数的方式是跳转到它的入口标签，就像在当前合约内部调用一个函数一样。

• 外部函数包含一个地址和一个函数签名，可以通过外部函数调用传递和返回。

需要注意的是，当前合约的公共函数可以同时作为内部和外部函数使用。要将 f 作为内部函数使用，只需使用 f，如果要将其作为外部函数使用，则使用 this.f。

如果函数类型的变量未初始化，调用该变量会导致 Panic 错误。如果在对其使用 delete 后调用函数，也会出现相同的错误。

声明语法

函数类型的声明语法如下：

function (<参数类型>) {internal|external} [pure|view|payable] [returns (<返回类型>)]

与参数类型不同，返回类型不能为空——如果函数类型不返回任何值，则整个 returns (<返回类型>) 部分必须省略。

默认情况下，函数类型是 internal，因此可以省略 internal 关键字。请注意，这仅适用于函数类型。对于在合约中定义的函数，必须显式指定可见性，它们没有默认值。

转换

当且仅当函数类型 A 和函数类型 B 的参数类型、返回类型、内部/外部属性相同，并且 A 的状态可变性比 B 更严格时，函数类型 A 可以隐式转换为函数类型 B。具体来说：

• pure 函数可以转换为 view 和非 payable 函数
• view 函数可以转换为非 payable 函数
• payable 函数可以转换为非 payable 函数

其他函数类型之间的转换是不可能的。

如果在 Solidity 的上下文之外使用外部函数类型，它们会被视为函数类型，该类型将地址和函数标识符一起编码在一个单一的 bytes24 类型中。

内部类型的函数可以被分配给一个内部函数类型的变量，无论它在哪里定义。这包括合约和库的 private、internal 和 public 函数，以及自由函数。另一方面，外部函数类型只能与公共和外部合约函数兼容。

注意
带有 calldata 参数的外部函数类型与带有 calldata 参数的外部函数类型不兼容。它们与相应的内存参数类型兼容。例如，没有一个函数可以被类型为 function (string calldata) external 的值指向，而 function (string memory) external 可以指向函数 f(string memory) external {} 和函数 g(string calldata) external {}。这是因为对于这两种位置，参数都以相同的方式传递给函数。调用方不能直接将其 calldata 传递给外部函数，并且始终将参数编码到内存中。将参数标记为 calldata 仅影响外部函数的实现，在调用方的函数指针中是没有意义的。

成员

外部（或公共）函数具有以下成员：

• .address 返回函数所在合约的地址。
• .selector 返回 ABI 函数选择器。

外部（或公共）函数曾经有额外的成员 .gas(uint) 和 .value(uint)。这些在 Solidity 0.6.2 中已被弃用，并在 Solidity 0.7.0 中移除。现在使用 {gas: …} 和 {value: …} 来指定发送给函数的 gas 数量或 wei 数量。有关更多信息，请参见外部函数调用。

合约更新时的值稳定性

在使用函数类型的值时，需要考虑一个重要的方面，即如果底层代码发生变化，值是否仍然有效。

区块链的状态并非完全不可变，并且有多种方法可以在同一地址下放置不同的代码：

• 通过加盐合约创建直接部署不同的代码。
• 通过 DELEGATECALL 委托到不同的合约（代理合约背后的可升级代码是一个常见的例子）。
• EIP-7702 定义的账户抽象。

外部函数类型可以被视为与合约的 ABI 一样稳定，这使得它们非常可移植。它们的 ABI 表示始终由合约地址和函数选择器组成，长期存储或在合约之间传递是完全安全的。虽然被引用的函数可能会发生变化或消失，但直接的外部调用将受到相同的影响，因此在这种使用方式下没有额外的风险。

然而，对于内部函数，值是一个与合约字节码紧密相关的标识符。标识符的实际表示是实现细节，并且可能在不同的编译器版本之间，甚至在不同的后端之间发生变化。以给定表示分配的值是确定性的（即，只要源代码相同，值就会保持不变），但容易受到变化的影响，例如添加、删除或重新排序函数。编译器还可以自由地删除从未使用的内部函数，这可能会影响其他标识符。一些表示方式，例如将标识符仅仅作为跳转目标的方式，可能会受到几乎任何变化的影响，即使这些变化与内部函数完全无关。

为了应对这种情况，Solidity 限制了在有效上下文之外使用内部函数类型。这就是为什么内部函数类型不能作为外部函数的参数（或以其他方式在合约 ABI 中暴露）使用的原因。然而，仍然有一些情况下，用户需要自行判断是否安全使用这些值。例如，虽然不推荐将这些值长期存储在状态变量中，但如果合约代码不会更新，那么这种做法可能是安全的。此外，使用内联汇编可以绕过这些安全限制，但这种做法需要格外小心。

示例

1、使用成员的代码示例：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.4 <0.9.0; // 设置 Solidity 编译器版本范围

contract Example {
    // 定义一个公共的、可支付的函数 f
    function f() public payable returns (bytes4) {
        // 使用 assert 检查函数 f 的地址是否与当前合约的地址相同
        assert(this.f.address == address(this));  // 检查 f 函数的地址是否等于当前合约地址
        // 返回 f 函数的 ABI 选择器（前 4 字节的哈希值）
        return this.f.selector;
    }

    // 定义一个公共函数 g，用来调用函数 f
    function g() public {
        // 使用 .f{gas: 10, value: 800}() 调用 f 函数，指定发送 800 wei 并且限制 gas 为 10
        this.f{gas: 10, value: 800}();
    }
}

2、使用内部函数类型的代码示例：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0; // 设置 Solidity 编译器版本范围

// 定义一个库 ArrayUtils，提供对数组进行操作的函数
library ArrayUtils {

    // 内部函数 map：接受一个 uint 数组和一个函数 f，将 f 应用于数组中的每个元素，并返回新的数组
    function map(uint[] memory self, function (uint) pure returns (uint) f)
        internal
        pure
        returns (uint[] memory r)
    {
        r = new uint[](self.length); // 创建一个与输入数组大小相同的新数组
        for (uint i = 0; i < self.length; i++) {
            r[i] = f(self[i]); // 对每个元素应用函数 f
        }
    }

    // 内部函数 reduce：接受一个 uint 数组和一个二元函数 f，对数组进行归约操作（折叠）
    function reduce(
        uint[] memory self,
        function (uint, uint) pure returns (uint) f
    )
        internal
        pure
        returns (uint r)
    {
        r = self[0]; // 初始化结果为数组的第一个元素
        for (uint i = 1; i < self.length; i++) {
            r = f(r, self[i]); // 对数组的每个元素应用函数 f
        }
    }

    // 内部函数 range：生成一个从 0 到 length-1 的 uint 数组
    function range(uint length) internal pure returns (uint[] memory r) {
        r = new uint[](length); // 创建一个指定长度的数组
        for (uint i = 0; i < r.length; i++) {
            r[i] = i; // 填充数组，元素为 0 到 length-1
        }
    }
}

contract Pyramid {
    using ArrayUtils for *; // 使用 ArrayUtils 库中的函数

    // 函数 pyramid：创建一个范围为 l 的数组，应用 square 函数进行变换，再使用 reduce 函数对数组进行求和
    function pyramid(uint l) public pure returns (uint) {
        return ArrayUtils.range(l).map(square).reduce(sum); // 生成数组，映射每个元素为平方值，然后进行求和
    }

    // 内部函数 square：返回输入值的平方
    function square(uint x) internal pure returns (uint) {
        return x * x;
    }

    // 内部函数 sum：返回两个输入值的和
    function sum(uint x, uint y) internal pure returns (uint) {
        return x + y;
    }
}

}

contract Pyramid {
    using ArrayUtils for *;

    function pyramid(uint l) public pure returns (uint) {
        return ArrayUtils.range(l).map(square).reduce(sum);
    }

    function square(uint x) internal pure returns (uint) {
        return x * x;
    }

    function sum(uint x, uint y) internal pure returns (uint) {
        return x + y;
    }
}

map 和 reduce 函数的定义使用了内部函数类型作为参数。

在 Pyramid 合约中，传递的 square 和 sum 函数正是符合这些内部函数类型的内部函数。

3、使用外部函数类型的代码示例：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.9.0; // 设置 Solidity 编译器版本范围

// 定义一个 Oracle 合约，用于请求数据并通过回调返回结果
contract Oracle {
    // 定义一个 Request 结构体，包含请求的数据和回调函数
    struct Request {
        bytes data; // 请求的数据，存储为字节数组
        function(uint) external callback; // 回调函数，接收一个 uint 参数并是外部可见的
    }

    Request[] private requests; // 存储所有请求的数组
    event NewRequest(uint); // 事件，用于记录新请求的 ID

    // query 函数：接受请求数据和一个外部回调函数
    function query(bytes memory data, function(uint) external callback) public {
        // 将请求添加到 requests 数组中
        requests.push(Request(data, callback));
        // 触发 NewRequest 事件，通知有新请求
        emit NewRequest(requests.length - 1);
    }

    // reply 函数：用于处理来自外部的响应，并触发回调
    function reply(uint requestID, uint response) public {
        // 这里进行检查，确保回复来自可信源
        requests[requestID].callback(response); // 调用请求中的回调函数，将响应传递给它
    }
}

// 定义一个 OracleUser 合约，模拟从 Oracle 获取汇率并处理响应
contract OracleUser {
    // 定义一个常量，Oracle 合约的地址，指向已知的 Oracle 合约
    Oracle constant private ORACLE_CONST = Oracle(address(0x00000000219ab540356cBB839Cbe05303d7705Fa)); // 已知合约
    uint private exchangeRate; // 存储汇率的状态变量

    // buySomething 函数：向 Oracle 请求数据（例如汇率）
    function buySomething() public {
        // 调用 Oracle 的 query 函数，传递数据和回调函数
        ORACLE_CONST.query("USD", this.oracleResponse);
    }

    // oracleResponse 函数：接收 Oracle 返回的响应，并更新汇率
    function oracleResponse(uint response) public {
        // 确保只有 Oracle 合约可以调用该函数
        require(
            msg.sender == address(ORACLE_CONST),
            "Only oracle can call this."
        );
        exchangeRate = response; // 更新汇率
    }
}

callback 作为外部函数类型，可以允许外部合约通过 Oracle 合约进行回调。

通过传递外部函数类型，Oracle 合约能够调用 OracleUser 合约中的 oracleResponse 函数，这样响应就可以被处理并且进行合约间交互。