【Gas优化】超优化 By Max-SMT

💡 本次解读的文章是2020年发表于 Springer 的一篇与智能合约 Gas 优化相关的论文， 在这篇文章中，作者提出了一种新的基于 Max-SMT 的智能合约超优化方法，该方法分为两个步骤：
（1）从智能合约的基本块中提取堆栈功能规范（Stack functional specification，SFS）；
（2）基于 SFS 抽象，通过 Max-SMT 编码，合成具备最少 gas 消耗的优化块字节码。

1、背景介绍

在区块链生态系统中，由于每天交易的数量较为庞大，且每笔交易需要消耗一定的交易费用（gas），因此，以节能的方式优化程序显得尤为重要。虽然，Solidity文档和一些相关文档给出了 gas 消耗的模式，提出用 gas-efficient 模式的替换，且 Solidity 的编译器也尝试优化字节码以最小化其 gas 消耗（如 solc 编译器的优化标志优化了大常数的存储和调度程序，以此减少 gas 的消耗），但是即便如此，编译后的 EVM 代码并不总是如期望的那样高效。

另外，在 Gas 优化的研究方面，超优化是30多年前提出的一种技术，它试图通过穷举搜索（exhaustive search）找到一个代码块的最佳翻译，以尝试产生相同结果的所有可能的指令序列，虽然这种方式简单，但是在计算量上的要求极高。文献$[1]$ 提出了“无界”超优化（“unbounded” super-optimization）的思想，即将对目标程序的搜索转移到求解器（solver）。而最近，这种“无界”超优化被应用于以太坊字节码基本块（basic block）的优化$[2]$，结果表明这一方法存在着极端的计算要求，而这种实施过程中的复杂性主要体现在三个方面：

1. 该问题用位向量算术理论（the theory of bit-vector arithmetic）表示，位宽大小为256，这对于大多数 SMT 求解器来说是一个具有挑战性的宽度尺寸；
2. 在表达问题过程中需要涉及到存在全量化（exists-forall quantification），因为希望找到一个对初始堆栈中所有值都有效的指令分配；
3. 由于解决思路是寻找 gas 最优字节码，所以这个问题不是一个满意度问题，而是一个最优化问题。

2、本文贡献

本文的贡献在于提出了一种基于 Max-SMT 合成优化 EVM 模块的智能合约 gas 优化方法，与其他工作的区别在于：

1. Stack functional specification（SFS，栈功能规范），本文的方法将 EVM 字节码作为输入，并基于通过符号执行获得字节码的 control-flow graph（CFG，控制流程图）来获取每一代码块的输入和输出 SFS。SFS 确定了块需要计算的目标栈，并使用一组规则进行简化，这些规则捕获了与 gas 优化相关的算术、位、关系等EVM操作的大部分语义。
2. Synthesis problem using SMT，本文将优化作为一个合成问题（synthesis problem）来处理，其中 SMT 求解器用于合成最优的 EVM 字节码，对于功能规范中给定的输入堆栈，生成由规范确定的目标堆栈。本文提出了一个非常有效的编码，与以前的尝试不同，在一个非常简单的整数算术片段中只使用存在量化（existential quantification），只有栈操作( PUSH、DUP、SWAP等)的语义被编码，而所有其他操作都被视为无解释的函数（uninterpreted functions）。
3. Use of Max-SMT，通过添加编码所选指令的 gas 成本的软约束来使用 Max-SMT 对优化问题进行编码，添加所需的权重，利用 Max-SMT 优化器改进搜索过程。
4. Experiments，在 ( i ) 用于评估工具 ebso 且来自$[2]$的相同数据集和 ( ii ) 以太坊区块链上最有名的128个合约进行评估。实验结果表明：与 ebso 在( i )中 92.12 % 的块中超时相比，本文的方法只在 8.64 % 的块中超时，并且获得了比 ebso 大两个数量级的增益；对于集合( ii )，本文的方法获得了占总 gas 的 0.59 %的节省。

虽然超优化的目的是在基本块（块内，intra-block）的水平上进行优化，但本文从给定的 SFS 中合成 EVM 码的方法也可以应用在更丰富的优化框架中，从而实现多个基本块（块间，inter-block）的优化。

3、合成过程介绍

在介绍本文的具体方法实现前，作者首先对从给定的 EVM 字节码合成超优化智能合约的方法进行了总体概述。在这部分中，本文以一段 Solidity 代码（左侧）和由 solc 编译器优化而成的 EVM 字节码（右侧）作为例子（Example），对合成优化代码的过程进行了描述。

3.1 字节码介绍

在了解合成流程之间，需要对本文涉及到的字节码有一定的认识。在字节码部分，本文依据字节码的含义对字节码进行了分类，并说明了字节码具体消耗的 gas 值，这些是为后续论文的优化过程做铺垫。

字节码分类

在字节码方面，本文主要分成了两大类，一类是仅仅指 DUP、PUSH、SWAP 和 POP 这些仅修改堆栈而不执行计算的堆栈操作码 stack operations，另一类是除 stack operations 的 other operations。

• stack operations：

（1）PUSHX: 字节码将值 A 存储在栈顶
（2）DUPX: 将存储在位置 X - 1 的元素复制到栈顶
（3）SWAPX: 将存储在栈顶的值与存储在位置 X 的值交换
（4）POP: 删除存储在栈顶的值（使用列表操作remove删除给定位置的元素）

• other operations：

（1）SLOAD、SSTORE: 访问存储在合约存储中的持久数据
（2）MLOAD、MSTORE: 访问存储在本地内存中的数据
（3）JUMP、JUMPI: 跳转到不同代码地址位置
（4）CALL、DELEGATECALL、CALLCODE、CALLSTATIC: 调用不同合约上的函数
（5）LOG: 写日志
（6）GAS、CALLER、BLOCKHASH: 访问关于区块链和交易的信息
（7）CODECOPY、RETURNDATACOPY: 复制与外部调用
（8）OP: 表示与栈操作相关的所有其他EVM字节码（算术和位运算等）

考虑到本文的方法是基于优化修改堆栈操作的，因此没有对那些在堆栈中没有体现效果的字节码进行优化，例如 MSTORE、SSTORE、LOG 或 EXTCODECOPY 等。另外，排除了 JUMPDEST 和 JUMP 这两个无法优化的操作码（即不参与 gas 消耗的计算）。

字节码 Gas 消耗

基于如文献3所述，来自so-called base family（如 POP）的操作消耗 2，来自verylow family（如PUSH、SWAP、ADD等）的操作消耗 3，来自low family（如MUL、DIV等）的操作消耗 5等等，计算得到实例对应的 gas 消耗为76。

3.2 合成流程介绍

在智能合约 gas 优化方面的思路是首先从 EVM 字节码中获取控制流图 CFG，接着利用 CFG 获取基本代码块，在代码块的基础上，提取 SFS 并以此作为优化算法的输入，合成 gas 消耗最小的字节码。其中，本文的工作主要是将构成字节码控制流图（CFG）的块集合作为输入，提取 SFS 并合成 gas 消耗最小的字节码，最终输出合成的优化字节码。

• SFS 的提取

在提取的过程中，以 CFG 获取的代码块对象作为输入，提取用于对进入块时的初始堆栈和执行块后的最终堆栈的功能描述 SFS。其中，SFS 主要通过对初始堆栈元素的符号一阶项来定义，Example 对应的 SFS 如图所示，图中左侧表示初始栈，右侧表示最终栈。初始栈包含五个元素 $x_0,\dots ,x_4$，最终栈包含两个元素：顶部为$x_4$，底部为符号项 $exp(x_2+x_3,x_0+x_1)$。

• 字节码的合成

本文利用两个例子说明了合成过程中不同选择所带来的 gas 消耗的不同，并展示了合成最优字节码的过程，这两个例子说明即使有指导搜索的函数规范，如果想确保找到最优的字节码，也必须穷尽所有可能的方法来获得它。

（1）Example 1

（2）Example 2

然而，与其他超优化方法不同，本文在处理所有的 non-stack operations 上进行了限制，如将ADD、SUB、AND、OR、LT 等作为未解释字节码（uninterpreted bytecodes），以此简化编码的过程：

1. 通过将它们视为无解释的字节码，可以避免使用宽度为256的位向量理论进行推理；
2. 可以在存在量化（existentially quantified）片段中表达问题，避免存在/整体（exists/forall）的交替：
   （1）从 SFS 开始，通过引入新变量（fresh variables）来抽象出用无解释的函数构建的所有项，这样每一个新变量代表一个项$f(a_1,\dots ,a_n)$，其中每一个 $a_i$ 是一个（256 bit）数值，或者是一个新变量（fresh variables），或者是一个初始堆栈变量（initial stack variable）。另外，还通过对每个项都有一个单一变量来共享，由此将无解释的字节码用数值进行简单表示。
   （2）为了避免全称量化，可以规定 PUSH 操作码在堆栈中只能引入0到$2^{256}-1$的值，因此，可以从 $2^{256}$ 开始给新变量（fresh variables）和初始堆栈变量（initial stack variable）赋值，以此避免它们与问题中其他值之间的混淆。

另外，本文对合成过程涉及的数值量进行了符号表示：

（1）一个解所允许的操作码的最大数目 $n$ 和栈的最大大小 $h$
（2）$O_0,\dots ,O_{n-1}$ 表示字节码操作
（3）$p_0,\dots ,p_{n-1}$ 表示当 $O_i$ 是 PUSH 时，添加入栈的值 $p_i$ ($0\le p_i\le 2^{256}-1$)
（4）$s_0^i,\dots ,s_{h-1}^i$ 表示执行操作 $O_i$ 前栈的内容，其中 $s_0^i$ 表示栈顶元素

对于无解释的字节码 $f_u$，有：$y=f_u(a_1,\dots ,a_m)$ ，其中 $a_1,\dots ,a_m$ 是第 $i$ 步中栈顶元素 $s_0^i,\dots ,s_{m-1}^i$，经过操作后可以得到第 $i+1$ 步骤执行前的栈顶元素 $y,s_m^i,\dots$。另外，本文还对 ADD、MUL、AND、OR等无解释字节码的交换性进行了编码，这主要通过考虑两个在堆栈顶部的参数发生的可能顺序，其他属性如联结性更难编码，留待未来发展。

进一步地，在 SMT 的基础上，本文采用了 Max-SMT进行最优合成。SMT 问题的每个解都将具有与给定解相同的 SFS，因此，只需要寻找 gas 成本最小的解。在$[2]$中，这是通过在 SMT求解过程的顶端实现一个循环来实现的，该循环调用求解器，每次请求一个 gas 方面更好的解，这也是在 SMT 问题中编码的。这样的方法不能很容易地以增量的方式实现，将 SMT 求解器作为一个黑盒而没有相应的性能惩罚。因此，本文提出将问题编码为一个 Max-SMT 问题，这样可以很容易地使用任何 Max-SMT 优化器，如Z3、Barcelogic或( Opti ) MathSAT，作为一个具有重要效率增益的黑盒。另外，Max-SMT 编码在之前定义的 SMT 编码中增加了一些软约束，表明了选择每个家族操作符的代价。

4、合成过程实现

如前文所述，最优代码的合成过程包括：1）控制流图获取；2）栈功能规范提取；3）最优字节码合成。其中，控制流图的获取不是本文的关注重点，目前的获取工具有EthIR, Madmax, Mythril 以及 Rattle等等。

4.1 栈功能规范提取

（1）block-partitioning，块划分

通过 CFG 的获取，可以得到 Base Block（基本块，即不包含任何 JUMP 字节码的EVM指令序列），这种基本块由于存在未优化的字节码指令，因此，需要执行进一步的块划分，将基本块划分成多个子块。对于给定的基本块 $B=\left[b_0,b_1,\dots ,b_n\right]$ ，块划分定义为：

blocks ⁡ ( B ) = { B i ≡ b i , … , b j ( ∀ k . i < k < j , b k ∉  Jump  ∪  Terminal  ∪  Split  ∪ {  JUMPDEST  } ) ∧ ( i = 0 ∨ b i − 1 ∈  Split  ∪ {  JUMPDEST  } ) ∧ ( j = n ∨ b j + 1 ∈  Jump  ∪  Split  ∪  Terminal  ) } \operatorname{blocks}(B)=\left\{\begin{array}{l|l} B_{i} \equiv b_{i}, \ldots, b_{j} & \left.\begin{array}{l} \left(\forall k . i<k<j, b_{k} \notin \text { Jump } \cup \text { Terminal } \cup \text { Split } \cup\right. \\ \{\text { JUMPDEST }\}) \wedge\left(i=0 \vee b_{i-1} \in \text { Split } \cup\{\text { JUMPDEST }\}\right)\wedge \\ \left(j=n \vee b_{j+1} \in \text { Jump } \cup \text { Split } \cup \text { Terminal }\right) \end{array}\right. \end{array}\right\} blocks(B)=⎩ ⎨ ⎧​Bi​≡bi​,…,bj​​(∀k.i<k<j,bk​∈/ Jump ∪ Terminal ∪ Split ∪{ JUMPDEST })∧(i=0∨bi−1​∈ Split ∪{ JUMPDEST })∧(j=n∨bj+1​∈ Jump ∪ Split ∪ Terminal )​​⎭ ⎬ ⎫​

其中：

 Jump  = {  JUMP, JUMPI  }  Terminal  = {  RETURN, REVERT, STOP, INVALID  }  Split  = {  SSTORE, MSTORE, LOGX, CALLDATACOPY, CODECOPY, EXTCODECOPY,   RETURNDATACOPY  } \begin{aligned} \text { Jump }= & \{\text { JUMP, JUMPI }\} \\ \text { Terminal }= & \{\text { RETURN, REVERT, STOP, INVALID }\} \\ \text { Split }= & \{\text { SSTORE, MSTORE, LOGX, CALLDATACOPY, CODECOPY, EXTCODECOPY, } \\ & \text { RETURNDATACOPY }\} \end{aligned}  Jump = Terminal = Split =​{ JUMP, JUMPI }{ RETURN, REVERT, STOP, INVALID }{ SSTORE, MSTORE, LOGX, CALLDATACOPY, CODECOPY, EXTCODECOPY,  RETURNDATACOPY }​

如前文所述，那些在堆栈上没有体现其作用的字节码将会导致分割，并在碎片化的子块中被省略。论文给出了一个具体的实例来说明块的划分。从图中可以看到，原始的 CFG 块包含字节码 SSTORE、MSTORE 和LOG2，因此，它被分割成三个不包含这些字节码的不同子块。

（2）SFS 的提取

在从 CFG 中获得子块后，需要使用符号执行获得输出堆栈（即执行块中字节码序列后的栈）的功能描述。由于在执行事务之前栈是空的，并且每个EVM字节码消耗和产生的元素个数已知，因此可以静态推断每个子块开始时栈的大小。规定符号栈 $S$ 是一个大小为 $k$ 的列表，表示栈的状态，其中列表位置 $0$ 对应栈的顶部，$k-1$ 是栈底部的索引，则 $S[i]$ 是存储在栈的位置 $i$ 的符号值。最初，输入栈将每个指标映射为一个符号变量 $s_i$，转换函数表示为 $\tau$，则对栈上操作的指令进行符号执行如下：

利用上述符号，可以给出 SFS 的定义为：给定一个堆栈初始大小为 $k$ 的块 $B$，初始堆栈 $S_0$ 在每个位置存储 $(i\in 0，...，k-1)$ 一个符号变量 $s_i$，然后，将传递函数 $\tau$ 扩展到块 $B$，记为 $\tau (B)$。若 $B$ 为空，则有$[s_0,\dots ,s_{k-1}]$；若 $B$ 有 $o$ 作为最后一次运算，则表示为 $\tau \left(\tau \left(B^{\prime }\right),o\right)$ ，其中，$B^{\prime }$ 表示是没有 $o$ 的结果块。依据上述定义可知，$B$ 的 SFS 表示为：${\mathcal{S}}_0⟹\mathcal{S}=\tau (B)$。

4.2 最优字节码合成

在提取了 SFS 后，接下来需要对 SFS、栈以及指令、gas消耗进行抽象表示，利用这些抽象表示来描述优化过程中的软约束、硬约束以及目标函数，再利用 Max-SMT 实现最优字节码的合成。

（1）SFS 抽象处理

对于堆栈初始大小为 $k$ 的栈有：

• 初始栈的 stack variables：$[s_0,\dots ,s_{k-1}]$
• 引入的 fresh variables：$s_k,s_{k+1},\dots$
• 映射关系 $M$（从 fresh variables 到由无解释的函数）

（2）堆栈模型建立

1. 栈内元素抽象

为了区分栈中 { 由 Push 操作引入的常数 constant } 和 { initial stack variables 以及除 Push 操作引入的 fresh variables }（这里的区分是为了后续约束条件的表示和判断），本文规定，由 Push 操作引入的 constant 取值范围是 { 0 , 2 256 − 1 } \{0, 2^{256}-1\} {0,2256−1}，由 initial stack variables 和 除 Push 操作引入的 fresh variables 的取值范围是：
$$S_V=\underset{0⩽i<v}{\bigwedge }{s}_i=2^{256}+i$$

2. 栈属性和操作抽象

在抽象化栈中的元素表示后，本文对栈的属性进行了符号化：

• $b_o$ : 操作次数（利用启发算法 heuristics 确定）
• $b_s$ : 栈的大小（利用启发算法 heuristics 确定）
• $x_{i,j}\in \mathbb{Z}$, i ∈ { 0 , … , b s − 1 } i \in \left \{0, \ldots, b_{s}-1\right\} i∈{0,…,bs​−1}, j ∈ { 0 , … , b s − 1 } j \in \left \{0, \ldots, b_{s}-1\right\} j∈{0,…,bs​−1} : 执行前 $j$ 个操作后，栈中 $i$ 位置的元素
• $u_{i,j}$, i ∈ { 0 , … , b s − 1 } i \in \left \{0, \ldots, b_{s}-1\right\} i∈{0,…,bs​−1}, j ∈ { 0 , … , b s − 1 } j \in \left \{0, \ldots, b_{s}-1\right\} j∈{0,…,bs​−1} : 执行前 $j$ 个操作后，栈中第 $i$ 个位置的元素是否存在
• $\mathrm{Move}(j,\alpha ,\beta ,\delta )={\bigwedge }_{\alpha ⩽i⩽\beta }{u}_{i+\delta ,j+1}=u_{i,j}\wedge x_{i+\delta ,j+1}=x_{i,j}$ : 为了简化后面的定义，本文引入了参数化约束，含义是给定一个指令 $j$，$0<j\le b_0$，两个栈位置 $\alpha$ 和 $\beta$ 以及移位量 $\delta \in \mathbb{Z}$，有 $0\le \alpha ,0\le \alpha +\delta ,\beta <b_s$ 和 $\beta +\delta <b_s$，使得在移位量为 $\delta$ 的情况下（如果为负则向上移动，否则向下移动），位置 $\alpha$ 和 $\beta$ 之间执行 $j+1$ 条指令后的栈与执行 $j$ 条指令后的栈相同。

（3）指令编码

本文将指令集 $\mathcal{I}$ 划分为了三个子集 ${\mathcal{I}}_C\uplus {\mathcal{I}}_U\uplus {\mathcal{I}}_S$，分别表示：

• ${\mathcal{I}}_C$ : 包含发生在抽象 SFS 的映射 $M$ 中的交换无解释的函数
• ${\mathcal{I}}_U$ : 包含发生在抽象 SFS 的映射 $M$ 中的非交换无解释的函数
• ${\mathcal{I}}_S$ : 包含栈操作：
  PUSH，它在栈顶引入一个高达32字节的元素；
  POP，移除栈顶部的元素；
  DUPk，将栈中位于 $k-1$ 的元素复制到栈的顶端，其中 k ∈ { 1 , … , 16 } k\in \{1, \ldots, 16\} k∈{1,…,16} ；
  SWAPk，将栈顶部元素与栈中位于 $k$ 的元素交换，其中 k ∈ { 1 , … , 16 } k\in \{1, \ldots, 16\} k∈{1,…,16} ；
  NOP，额外的操作，表示什么也不做。

利用 $\theta$ 表示从指令集 $\mathcal{I}$ 到连续不同非负整数 { 0 , … , m l } \{0, \ldots, m_{l}\} {0,…,ml​} 的映射，则 $m_l+1$ 表示指令集的基数，为了在每一步对选择的指令进行编码，本文引入了存在量化变量 t j ∈ { 0 , … , m l } , j ∈ { 0 , … , b o − 1 } t_{j} \in \{0, \ldots, m_{l}\}, j\in\{0, \ldots, b_{o}-1\} tj​∈{0,…,ml​},j∈{0,…,bo​−1}，表示对于每个指令 $l\in \mathcal{I}$ 有：如果 $t_j=\theta (l)$，则在步骤 $j$ 执行的操作为 $l$。此外，本文引入了相关的存在量化变量 a j ∈ { 0 , … , 2 256 − 1 } a_{j}\in\{0, \ldots, 2^{256}-1\} aj​∈{0,…,2256−1}，其中 j ∈ { 0 , … , b o − 1 } j\in\{0, \ldots, b_{o}-1\} j∈{0,…,bo​−1}，表示当 $t_j=\theta (PUSH)$ 时堆栈顶端的值，否则 $a_j$ 的值无意义。在定义了需要的符号表示后，本文开始对优化过程的约束条件进行定义。

Encoding the Stack Operations

$$\begin{array}{l}{C}_{\mathrm{PUSH}}(j)=t_j=\theta (\mathrm{PUSH})\Rightarrow 0\le a_j<2^{256}\wedge \neg u_{b_s-1,j}\wedge u_{0,j+1}\wedge x_{0,j+1}\\ =a_j\wedge \text{Move}\left(j,0,b_s-2,1\right)\\ C_{\mathrm{DUP}k}(j)=t_j=\theta (\mathrm{DUP}k)\Rightarrow \neg u_{b_s-1,j}\wedge u_{k-1,j}\wedge u_{0,j+1}\wedge x_{0,j+1}=x_{k-1,j}\wedge \\ \mathrm{Move}\left(j,0,b_s-2,1\right)\\ C_{\mathrm{SWAP}k}(j)=t_j=\theta (\mathrm{SWAP}k)\Rightarrow u_{k,j}\wedge u_{0,j+1}\wedge x_{0,j+1}=x_{k,j}\wedge u_{k,j+1}\wedge \\ x_{k,j+1}=x_{0,j}\wedge \mathrm{Move}(j,1,k-1,0)\wedge \mathrm{Move}\left(j,k+1,b_s-1,0\right)\\ C_{\mathrm{POP}}(j)=t_j=\theta (\mathrm{POP})\Rightarrow u_{0,j}\wedge \neg u_{b_s-1,j+1}\wedge \mathrm{Move}\left(j,1,b_s-1,-1\right)\\ C_{\mathrm{NOP}}(j)=t_j=\theta (\mathrm{NOP})\Rightarrow \mathrm{Move}\left(j,0,b_s-1,0\right)\end{array}$$
当 NOP 出现在中间步骤时，为了避免冗余解，本文还增加了一个约束，即一旦选择 NOP 作为指令 $t_j$，之后只能选择 NOP 作为接下来的指令 $t_j+1,t_j+2,\dots$（因为 NOP 表示什么都不做，所以类似提前结束）:

$$C_{\text{fromNOP }}=\underset{0⩽j<b_o-1}{\bigwedge }{t}_j=\theta (\mathrm{NOP})\Rightarrow t_{j+1}=\theta (\mathrm{NOP})$$
Encoding the Uninterpreted Operations

无解释的操作编码来自抽象后的 $SFS$ 的映射 $M$，如前文所述，每个函数 $f$ 在 $M$ 中只出现一次，且对于 $M$ 中的每一个 $r\mapsto f\left(o_0,\dots ,o_{n-1}\right)$，有 $f\in {\mathcal{I}}_C\uplus {\mathcal{I}}_U$，$r$ 为新变量，$o_0,\dots ,o_{n-1}$ 为初始堆栈变量、新变量或常数。另外，对于 $f\in {\mathcal{I}}_C$，由于涉及交换操作，所以有 $n=2$。这些抽象表示对应的具体过程是，当遇到无解释操作函数时，利用操作数 $o_0,\dots ,o_{n-1}$ （$o_0$ 表示栈顶元素）操作得到结果 $r$，再将 $r$ 存放于栈顶。对应的约束条件表示如下：

$$\begin{array}{rl}{C}_U(j,f)=t_j=\theta (f)\Rightarrow & \underset{0⩽i⩽n-1}{\bigwedge }\left(u_{i,j}\wedge x_{i,j}=o_i\right)\wedge u_{0,j+1}\wedge x_{0,j+1}=r\wedge \\ & \mathrm{Move}\left(j,n,\min \left(b_s-2+n,b_s-1\right),1-n\right)\wedge \\ & \underset{b_s-n+1⩽i⩽b_s-1}{\bigwedge }\neg u_{i,j+1}\\ C_C(j,f)=t_j=\theta (f)\Rightarrow & u_{0,j}\wedge u_{1,j}\wedge \\ & \left(\left(x_{0,j}=o_0\wedge x_{1,j}=o_1\right)\vee \left(x_{0,j}=o_1\wedge x_{1,j}=o_0\right)\right)\wedge \\ & u_{0,j+1}\wedge x_{0,j+1}=r\wedge \mathrm{Move}\left(j,2,b_s-1,-1\right)\wedge \neg u_{b_s-1,j}\end{array}$$

其中：

$$\begin{array}{r}f\in {\mathcal{I}}_U\text{ and }r\mapsto f\left(o_0,\dots ,o_{n-1}\right)\in M\\ f\in {\mathcal{I}}_C\text{ and }r\mapsto f\left(o_0,o_1\right)\in M\end{array}$$

Finding the Target Program

由上述约束条件可得，指令集 $\mathcal{I}$ 对应的约束条件为：

$$\begin{array}{l}{C}_{\mathcal{I}}=C_{\text{fromnop }}\wedge {\bigwedge }_{0⩽j<b_o}0\le t_j\le m_{\iota }\wedge \\ C_{\mathrm{PUSH}}(j)\wedge C_{\mathrm{DUP}k}(j)\wedge C_{\mathrm{SWAP}k}(j)\wedge C_{\mathrm{POP}}(j)\wedge \\ C_{\mathrm{NOP}}(j)\wedge {\bigwedge }_{f\in {\mathcal{I}}_U}{C}_U(j,f)\wedge {\bigwedge }_{f\in {\mathcal{I}}_C}{C}_C(j,f))\end{array}$$
Complete Encoding

由于 $C_{SFS}$ 描述了为给定的初始栈 $[s_0,\dots ,s_{k-1}]$ 找到一个EVM块的整个问题，并通过最终栈 $[f_0,\dots ,f_{w-1}]$ 和 $M$ 抽象出 SFS。因此，这里引入一个约束 $B$ 来描述堆栈在开始时的情况，引入一个约束 $E$ 来描述堆栈在结束时的情况，并结合前面定义的所有约束来表示 $C_{SFS}$：

$$\begin{array}{l}B={\bigwedge }_{0⩽\alpha <k}\left(u_{\alpha ,0}\wedge x_{\alpha ,0}=s_{\alpha }\right)\wedge {\bigwedge }_{k⩽\beta ⩽b_s-1}\neg u_{\beta ,0}\\ E={\bigwedge }_{0⩽\alpha <w}\left(u_{\alpha ,b_o}\wedge x_{\alpha ,b_o}=f_{\alpha }\right)\wedge {\bigwedge }_{w⩽\beta ⩽b_s-1}\neg u_{\beta ,b_o}\\ C_{SFS}=S_V\wedge C_{\mathcal{I}}\wedge B\wedge E\end{array}$$

另外，本文添加了一条额外的约束来提高效率：${\bigwedge }_{\iota \in {\mathcal{I}}_U\uplus {\mathcal{I}}_C}{\bigvee }_{0⩽j<b_o}{t}_j=\theta (\iota )$

（4）操作提取

这里论文展示了如何从计算给定 $C_{SFS}$ 模型中提取一组具体的操作，具体定义为：给定一个 $C_{SFS}$ 模型 $\sigma$，定义 $block(\sigma )$ 为 EVM 运算序列 $o_0,\dots ,o_f$，其中 $f$ 是最大的 j ∈ { 0 , … , b o − 1 } j\in\{0, \ldots, b_{o-1}\} j∈{0,…,bo−1​} 且使得 $t_j=\theta (NOP)$，现在对所有的 α ∈ { 0 , … , f } \alpha\in\{0,\ldots, f\} α∈{0,…,f}，$o_{\alpha }$取为：

这些取值的选择将服从之前定义的 $C_{SFS}$ 约束条件，利用约束条件和操作提取的选择，可以建立所有满足条件的运算序列，即多个 $block(\sigma )$。

（5）Max-SMT 优化

一个（部分加权） Max-SMT 问题是一个优化问题，其中有一个 SMT 公式，表示建立问题的硬约束和一组对 { [ C 1 , ω 1 ] , … , [ C m , ω m ] } \left\{\left[C_{1}, \omega_{1}\right], \ldots,\left[C_{m}, \omega_{m}\right]\right\} {[C1​,ω1​],…,[Cm​,ωm​]}，每个 $C_i$ 是 SMT 子句，${\omega }_i$ 是其权重，以此建立软约束。

在获取了多个 $block(\sigma )$ 后，需要从中选择一个最优的运算序列（最优字节码），由于求解的成本可以用在所有 $t_j$ 中选择的每个指令的成本来表示，因此本文引入了表示每个选择成本的软约束，再结合前文的约束条件构成的硬约束，建立 Max-SMT优化问题，并以消耗最少 gas 为目标函数，进行最优合成字节码的求解。

在这个过程中，需要注意的是，在EVM中，每个操作都有一个相关的 gas 成本，一般情况下是恒定的，但在某些情况下可能取决于它应用到的特定参数或区块链的状态。所有这些非常数的操作都被认为是无解释的，不能改变它们所应用的操作数。而省略非常数部分不会影响哪个是最优解，因此，可以将指令集 $\mathcal{I}$ 拆分成 $p+1$ 个不交集 $W_0\uplus \dots \uplus W_p$，其中 $W_i$ 中的所有指令的成本 $cos{t}_i$ 是恒定的常数，并且使得成本严格递增，即 $cos{t}_0=0$ 且 c o s t i − 1 < c o s t i , i ∈ { 1 , … , p } cost_{i - 1} \lt cost_{i}, i \in \{1,\ldots,p\} costi−1​<costi​,i∈{1,…,p}。另外，设 ω i = c o s t i − c o s t i − 1 , i ∈ { 1 , … , p } \omega_{i} = cost_{i}-cost_{i-1}, i\in\{1,\ldots,p\} ωi​=costi​−costi−1​,i∈{1,…,p} ，则有 c o s t i = ∑ 1 ⩽ α ⩽ i w α , i ∈ { 1 , …   p } cost_{i}=\sum_{1 \leqslant \alpha \leqslant i} w_{\alpha},i\in\{1,\ldots\,p\} costi​=∑1⩽α⩽i​wα​,i∈{1,…p}，然后，在 $C_{SFS}$ 中加入软约束，得到 Max - SMT 问题 $O_{SFS}$：

$$O_{SFS}=C_{SFS}\wedge \underset{0⩽j<b_o}{\bigwedge }\underset{1⩽i⩽p}{\bigwedge }\left[\underset{\iota \in W_0\uplus \dots \uplus W_{i-1}}{\bigvee }{t}_j=\theta (\iota ),w_i\right]$$
因此，如果在第 $j$ 步选择的指令为 $l,t_j=\theta (\iota )$，对于 $l\in W_i$，可以累积所有 α ∈ { 1 , … , i } \alpha\in \{1,\ldots,i \} α∈{1,…,i}的软子句权重 ${\omega }_{\alpha }$，并记为 $cos{t}_i$，从而累积执行指令 $\iota$ 的代价。

相关概念

• Ethereum Virtual Machine（EVM，以太坊虚拟机）
  EVM 用于运行以太坊开发者编写的智能合约，EVM 是一种简单的基于堆栈的体系结构，即 EVM 的计算基于堆栈的字节码语言完成，机器的字大小为256位( 32字节)，这也是堆栈项的大小。

• Basic block（基本块）
  一个由一系列指令组成的基本块，其中间没有任何 JUMP 操作。

• Gas （燃料）
  成功进行交易或执行智能合约所需的费用或价值，gas 消耗主要来自每个EVM指令所对应的计算和存储成本。其中，计量 gas 的原理是三重的：
  （1）执行 gas 计量时对事务能够执行的操作数量进行限制，防止基于非终止执行的攻击；
  （2）不允许提议者在创建交易并支付 gas 时浪费其他方(也就是矿工)的计算资源；
  （3）gas 费用阻碍了用户过度使用复制存储，因为复制存储是基于区块链的共识系统中宝贵的资源。

• Super-optimization（超优化）
  超优化是一种通过尝试所有可能产生相同结果的指令序列来寻找代码块的最佳翻译的技术。

• Stack functional specification（SFS，栈功能规范）
  SFS 是对进入块时的初始堆栈和执行块后的最终堆栈的功能描述，它通过对初始堆栈元素的符号一阶项来定义，而不是使用字节码指令来确定最终堆栈是如何计算的。

参考文献

$[1]$ Jangda, A., Yorsh, G.: Unbounded superoptimization. In: Proceedings of the 2017 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, Onward! 2017, Vancouver, BC, Canada, 23–27 October 2017, pp. 78–88 (2017)
$[2]$ Mesnard, F., Stuckey, P.J. (eds.): LOPSTR 2018. LNCS, vol. 11408. Springer, Cham (2019). https://doi.org/10.1007/978-3-030-13838-7
$[3]$ Wood, G.: Ethereum: a secure decentralised generalised transaction ledger (2019)