CN110870249A

CN110870249A - 用于将高级语言代码编译为区块链平台上可执行的脚本的系统和方法

Info

Publication number: CN110870249A
Application number: CN201880045600.6A
Authority: CN
Inventors: C·S·赖特; S·萨瓦纳
Original assignee: Nchain Holdings Ltd
Current assignee: Nchain Holdings Ltd
Priority date: 2017-07-07
Filing date: 2018-07-05
Publication date: 2020-03-06
Also published as: ZA201908552B; JP2023100981A; US11922149B2; US20240231777A1; JP2020526814A; JP7317722B2; US20240211222A1; US11868745B2; WO2019008531A1; US20210081185A1; CN110869906B; US20200174762A1; EP4300290A3; JP2023052782A; CN110869905B; KR20200021993A; JP2024116281A; JP2020526811A; KR102608500B1; WO2019008533A1

Abstract

提供了一种计算机实现的方法(以及相应的系统)，其使得能够或便利于在区块链平台上执行以高级语言(HLL)编写的部分源代码。该方法和系统可以包括区块链编译器，其被设置为将一部分高级源代码转换成可以与区块链平台一起使用的形式。这可以是比特币区块链或其他替代方案。该方法可以包括：接收部分源代码作为输入；以及生成包括多个操作码的输出脚本。操作码是功能受限的区块链脚本所固有的操作码的子集。设置和/或生成输出的脚本，以便在执行时，脚本至少部分提供源代码中指定的功能。限制区块链脚本语言，使得其不固有地支持复杂的控制流结构或通过基于跳转的循环或其他递归编程结构进行递归。生成输出脚本的步骤可以包括展开源代码中提供的至少一个循环结构。该方法可以进一步包括提供或使用解释程序或虚拟机，该解释程序或虚拟机被设置为将输出脚本转换成在区块链平台上可执行的形式。

Description

用于将高级语言代码编译为区块链平台上可执行的脚本的系统和方法

技术领域

本公开总体上涉及分布式账本技术，并且更具体地涉及诸如比特币网络和相关协议之类的区块链技术。本发明还涉及用于转换基于计算机的代码的编译器和与编译器相关的技术。本发明的一个或多个实施方式适于用作如下解决方案，该解决方案使得能够在区块链平台或协议上自动化和执行高级程序和/或便利该自动化和执行，该区块链平台或协议包括功能上受限的基于脚本的语言。

背景技术

在本文中，我们使用术语“区块链”来涵盖所有形式的基于计算机的电子分布式账本技术。这些包括基于共识的区块链和交易链技术、经许可和未经许可的账本、共享账本及其变体。区块链技术最广为人知的应用是比特币账本，尽管已经提出并开发了其他区块链实现方式。尽管出于方便和说明的目的在本文中可以提及比特币，但是应当注意，本发明不限于与比特币区块链一起使用，并且替代的区块链实现方式和协议落入本发明的范围内。术语“用户”在此可以指人类或基于处理器的资源。

区块链是一种点对点的电子账本，其被实现为基于计算机的去中心化的分布式系统，该系统由区块组成，而区块又由交易组成。每个交易是一个数据结构，该数据结构对区块链系统中的参与者之间的数字资产的控制转移进行编码，并包括至少一个输入和至少一个输出。每个区块包含前一个区块的散列，以致于这些区块变为链接在一起，以创建自区块链开始以来就已经写入区块链的所有交易的永久、不可更改的记录。交易包含嵌入其输入和输出中称为脚本的小程序，它们指定如何以及通过谁来访问交易的输出。在比特币平台上，这些脚本是使用称为Script的基于堆栈的脚本语言来编写的。脚本使用通过解释程序转换为可执行代码的命令(操作码)来编写。

为了将交易写入区块链，必须对其进行“验证”。网络节点(矿工)进行工作以确保每次交易都有效，而无效交易从网络中被拒绝。安装在节点上的软件客户端通过执行其锁定和解锁脚本，来对未耗用的交易(UTXO)进行该验证工作。如果锁定和解锁脚本的执行评估为TRUE且可能通过了其他检查，则交易有效并且被写入区块链。因此，为了将交易写入区块链，该交易必须i)由接收交易的第一节点来验证-如果交易被验证，则节点将其中继到网络中的其他节点；ii)被加入由矿工建造的新区块；iii)被挖掘，即加入过去交易的公共账本。

虽然区块链技术最广为人知的地方在于加密货币实现方式的使用，但是数字企业家已经开始探索比特币所基于的加密安全系统以及可以存储在区块链上以实现新系统的数据这两者的使用。如果区块链可用于并不限于加密货币领域的自动化任务和过程，这将是非常有利的。这样的解决方案将能够利用区块链的好处(例如，事件的永久性、防篡改记录，分布式处理等)，同时在其应用中更通用。因此，需要对新应用和技术创新更广泛地使用该技术，这就类似于早期使用因特网，随后在基于网络系统的开发方面蓬勃发展那样。

然而，以脚本语言编写程序例如不为更广泛的编程社区直观地容易接受，因为其需要有关于低级编程技术的知识和技巧。其需要程序员考虑堆栈以及其中数据的位置。编写低级操作码组成的程序比以高级语言(HLL)比如C、Java等编写源代码更加耗时且劳动密集。为该HLL构建的编译器/解释程序提供了一个方便的抽象层，该层使得程序员远离与内存管理等有关的更费力的低级问题。编写操作码的序列来操纵一个或更多个堆栈中的数据比以HLL编写源代码技术上更复杂和耗时。因此，由于使用低级操作码的困难性，更容易发生错误和缺陷。

此外，HLL使程序员能够在其源代码中包括复杂控制流结构比如循环、case语句和递归调用。程序员可以专注于所需的逻辑并以直观的方式通过诸如“while this is true，do X...(当这是真的，做X…)”之类的机制来表达逻辑流程。然而，一些与区块链相关联的脚本语言比如比特币的Script在功能上受限制，因为它们包括比如算术运算这样的经典运算符，也包括比如哈希运算符和签名验证这样的加密功能，然而不包括用于复杂控制结构(比如while循环)的固有原语，也不允许使用递归技术，如在HLL中能够使用的那样。该受限制的语言不支持基于跳转的控制流。因此，通过设计，其限制了提供给程序员以包括在源代码中的语言和逻辑结构。这导致一些人争辩说比如Script这样的受限制语言是非图灵完整的，虽然该定义被其他人提出异议。因此，在此将使用短语“功能受限制”。

应注意，尽管这种故意限制会使编码过程对于程序员来说更加困难，然而其也使得程序执行时间有界限，且重要的是，提供了重要的安全机制，因为其防止了恶意利用(exploits)，比如防止了使用无限循环来实施拒绝服务(DoS)攻击。

因此，在关键性的安全性和需要便利于、鼓励和改进基于区块链技术的发展之间存在权衡。为了解决后一个问题，以太坊在其区块链平台中包括HLL语言作为固有功能。如Script那样，需要低级解释程序来产生代码的可执行版本。以太坊的HLL语言(称为Ether)允许通过使用有条件和无条件跳转来执行控制流。其还允许递归。为了避免比如DoS攻击之类的问题，以太坊通过引入gas这一概念来限制交易执行时间，gas是预先支付从而覆盖执行成本的一部分加密货币。因此，由于使用固有HLL，需要另外一层技术和商业上的复杂性。此外，以太坊到目前为止还遭受了至少一个基于递归的重大攻击。参见例如：

http://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/

因此，期望提供一种机制，程序员可通过该机制使用其熟悉的HLL语言以更容易、快速和高效的方式开发、设计和产生有效的区块链解决方案，而不损害功能上受限制的脚本语言提供的安全性。这绝不是一项微不足道的任务，该任务是需要相当大程度的技术创新的。这是本发明解决的技术问题之一。

发明内容

因此，根据本公开，提供了如所附权利要求书中所定义的系统和相应方法。

根据本公开，可以提供一种计算机实现的方法和相应的系统。该方法可以被设置为使得能够在区块链平台上执行一部分源代码，或便利于其执行。源代码可以用高级语言编写。本公开描述了可以被实现为软件编译器的编译技术和系统/组件。以下可将其称为“区块链护比特币编译器”。可将软件编译器设置为结合比特币区块链或任何其他基于区块链的协议/网络来使用。

有利的是，本公开的软件编译器可以使得用户(程序员)能够以熟悉的语言(比如C、Java、C++的语法格式)来编写和创建区块链可执行的程序/应用。这将基于区块链的开发这一任务扩展到更宽广的开发社区。这也意味着，基于区块链的解决方案可更快速地编写，并且可以由本发明进行错误检查，下文对此进行更详细描述。至为重要的是，底层协议和相关联脚本语言的安全功能得以保留和维护。因此，本发明提供了一种技术和系统用于在脚本生成过程中保留与区块链有关的安全性，并便利于生成有效的无错误脚本(以及交易)或使得能够生成该有效的无错误脚本(以及交易)，该无错误脚本(以及交易)由区块链网络上的节点验证。

根据一个可能的实施方式，可以提供一种计算机实现的方法，该方法使用静态编译来将一部分源代码转换成区块链兼容的脚本。这可以被称为“输出脚本”，因为其可形成编译器提供的输出。本发明可针对一个或更多个错误进行测试。其可在检测到一个或更多个错误时提供警报。静态编译可包括循环展开的步骤；在所述一部分源代码内提供的一个或更多个循环可被展开。应注意，术语“静态编译”和“循环展开”是本领域已知的术语，且容易为本领域技术人员所理解。

可将该方法布置为与区块链网络一起使用。区块链网络可与协议相关联。其可以是“工作量证明”的区块链。其可以是基于共识的区块链。其可以是公共和/或未经许可的区块链。其可以是点对点、去中心化的区块链。

区块链网络可以包括验证区块链交易的多个节点。区块链交易可以包括可由多个节点执行的脚本。脚本可由属于功能上受限制(或称为非图灵完整)的区块链脚本语言的一组操作码表示或包括该一组操作码。该方法可以包括步骤：生成输出脚本以包括在区块链交易中，该区块链交易由区块链网络的节点验证。输出脚本可由属于功能上受限制的区块链脚本语言的一组操作码表示，且输出脚本可被设置或改写，使得区块链网络的节点对脚本的执行可实施源代码中指定的功能。

该部分源代码可以用高级语言(HLL)编写。HLL可被描述为可编译HLL。HLL可由根据本发明设置的软件组件(编译器)来编译。HLL可由编译器来编译，从而产生可由解释程序执行的脚本。脚本可设置在区块链交易(Tx)中。脚本可以与交易的输入或输出相关联。HLL可以是图灵完整的语言(受现实世界约束)，因为其可允许实现复杂控制流(比如递归)、复杂选择结构和/或循环的表达式、结构和/或语句。HLL固有的语法可以包括与循环有关的语法比如WHILE、FOR或REPEAT循环。其可以包括用于执行加密运算、算术运算和堆栈操纵运算的原语。HLL可以包括定制的操作码和/或高级语言结构，基本如下所述。

区块链兼容的脚本可以是由从区块链上执行的区块链脚本语言中选择的、该语言固有的和/或形成该语言一部分的操作码来形成的脚本(即程序)。操作码可以被称为原语或命令。脚本可在于区块链上执行/可执行之前，通过解释程序或虚拟机。(术语“区块链”在该上下文中可以包括协议和实施平台)。解释程序可以将该脚本转换成机器可执行(对象)代码。区块链脚本语言可以例如是结合比特币协议或其变体使用的Script语言。脚本语言可被设置为与区块链协议一起使用。脚本语言可以包括加密操作码、算术操作码和堆栈操纵操作码。

区块链脚本语言可以在功能上受限制。其可在语法/解释程序被设置允许或处理的功能方面受限制。其可能不固有地支持复杂控制流比如递归、复杂选择结构和/或循环。

另外或作为替代，可以提供一种方法，该方法被设置为使得能够在区块链平台上执行以高级语言(HLL)编写的一部分源代码，或便利于该执行。源代码可被设置为实现智能合约。智能合约可以是机器可读且可执行的应用程序，可在区块链上执行，如现有技术已知的那样。

该方法可以包括步骤：接收该一部分源代码作为输入。其可以由软件实施的编译器来接收。

该方法可以包括步骤：生成输出脚本。这可以是如上所述的区块链兼容的脚本。其可以包括从功能上受限制的区块链脚本语言选择的和/或其固有的多个操作码。该脚本语言可以如上所述。在执行时，该脚本可以至少部分地提供源代码中指定的功能。

该方法可以包括步骤：提供或使用被设置为执行上述任何方法实施方式的编译器。可通过执行静态编译来生成输出脚本。

使用静态编译提供了如下优点：产生的脚本将总是停止。这不仅在运行时提供了实际的好处，而且使本发明能用作验证工具，因为如果在源代码中遇到了某种类型的错误或无效结构，区块链编译器将停止。在脚本开发期间能够使用验证工具这一优势意味着：编程任务通过减少程序员时间和工作量得到增强。进一步，区块链编译器提供了一种安全性的解决方案，因为其对缺陷和溢出错误进行测试，这使得用户(程序员)能够静态地测试程序是否将执行且安全地执行。

区块链脚本语言可以受限制，使得其不通过基于跳转的循环或其他递归编程结构固有地支持复杂控制流结构或递归。生成输出脚本的步骤可以包括展开源代码中提供的至少一个循环结构。该方法可以包括步骤：提供或使用解释程序或虚拟机，其被设置成将输出脚本转换成可在区块链平台上执行的形式。

该方法还可以包括步骤：至少一次优化输出脚本，从而提供更高效或简化版本的输出脚本。这可以包括使用无导数优化(derivative free optimisation，DFO)。DFO是本领域已知的术语，容易为本领域技术人员所理解。另外或作为替代，生成输出脚本的步骤可以包括使用无导数优化。

区块链编译器可被设置为形成软件开发工具包(SDK)的一部分和/或结合软件开发工具包一起操作。SDK可以包括编辑器、调适器和已知与SDK一起使用的其他组件，以便利于生成基于代码的解决方案。

HLL可以包括至少一个原语、运算符或结构，其可被直接转换为区块链脚本语言固有的一个或更多个原语/命令/操作码。

区块链脚本语言可以是基于堆栈的。其可以被设置成操纵一个或多个堆栈。HLL可以包括一个或更多个原语或运算符，该原语或运算符被设置成导致在脚本语言使用的堆栈上执行操作。

HLL可以包括如下原语或结构，该原语或结构被设置成将至源代码的输入的数量推到区块链脚本语言进行内存分配而使用的堆栈上。HLL可以包括一个或更多个原语，该一个或更多个原语被设置成导致执行加密运算或功能、算术运算和/或循环。

HLL可以包括以下原语或运算符或其各个功能等同物中的至少一个：

Initiate；

Declare；

Increment；

IF；

While；

Populate；

Monus；

Reset；

Rawscript；

Abort；

Retrieve

Hash,hash 160，或其他hash操作或其变体。

本公开可以提供一种方法，该方法包括以下步骤：使用静态编译将一部分源代码转换成与区块链兼容的脚本。静态编译可以包括循环展开的步骤。

该一部分的源代码可以包括至少一个高级编程结构。可以通过将高级编程结构转换成属于功能上受限制的区块链脚本语言的一个或更多个操作码来生成输出脚本。输出脚本的一个或更多个操作码可以被设置或改写，使得通过区块链网络的节点执行一个或更多个操作码来实施源代码的至少一个高级编程结构(的功能)。

优选地，功能上受限制的区块链脚本语言不支持循环结构。优选地，至少一个高级编程结构包括循环结构。优选地，通过展开循环结构(loop construct)(也可称为“循环结构(looping construct)”)生成脚本。优选地，循环结构包括代码块和指定迭代次数的实际参数argument，以及展开循环结构包括以上述迭代次数编写用于代码块的功能的操作码。

该方法还可以包括以下步骤：检查循环结构的语法，从而确保循环结构包括指定迭代次数的实际参数argument，且确保该实际参数argument满足指定最大迭代次数的约束。

循环结构可以包括代码块和用于基于至少一个变量来指定循环结构的迭代次数的条件。优选地，展开循环结构包括：结合编写操作码命令，复制用于代码块的功能的操作码，基于使用根据输出脚本的执行确定的变量值而对条件的评估，上述操作码命令以最大迭代次数选择性执行复制的用于代码块的功能的操作码。

根据本公开，提供一种计算机实现的系统，该计算机实现的系统被设置成实现此处描述的任何方法实施方式的步骤。

根据本公开的实施方式的计算机实现的系统可以包括编译器。编译器可以被设置为接收一部分源代码作为输入。源代码可以用高级语言(HLL)编写。编译器可以被设置为生成输出脚本。输出脚本可以被称为“区块链脚本”或“区块链兼容脚本”，并且可以包括多个操作码。可以从如上所述的功能受限的区块链脚本语言中选择这些操作码，和/或这些操作码是该语言固有的，以使得在执行时，脚本至少部分地提供源代码中指定的功能。

该系统可以包括软件开发工具包(SDK)。编译器可以构成DSK的一部分。

本发明还提供一种系统，包括：

处理器；以及

包括可执行指令的存储器，该可执行指令由于处理器的执行而导致系统执行本文所述的计算机实现的方法的任何实施方式。

本发明还提供一种其上存储有可执行指令的非暂时性计算机可读存储介质，该可执行指令由于由计算机系统的处理器执行而导致该计算机系统至少执行在此所述的该计算机实现的方法的实施方式。

以上关于本公开的一个方面或一个实施方式描述的任何特征也可应用于一个或更多个其他方面或实施方式。关于本公开的方法描述的任何特征可同等地应用于根据本公开的系统，反之亦然。

附图说明

通过在此描述的实施方式，本发明的这些和其他方面将变得明显，且将参考在此所述的实施方式阐述本发明的这些和其他方面。现在参考附图仅作为示例描述本发明的实施方式，在附图中：

图1示出了本发明的概览。

图2提供了如关于以下展开while循环的例子中所述的、用于填充Try[]的代码块。

图3示出了可实现各种实施方式的区块链环境。

图4示出了根据实施方式的用于验证和挖掘引用先前区块链交易的耗用区块链交易的区块链协议；

图5示出了可以在其中实现各种实施方式的计算环境。

具体实施方式

概要

此后，我们会提到比特币协议、区块链、网络或脚本语言，仅是为了便于参考，因为这是最广为人知和被采用的。然而，本发明不限于与比特币相关的区块链一起使用，并且其他区块链技术也落入本公开的范围内。

如上所述，当今大多数程序员都使用高级语言(例如C、C++、Java等)编写代码，而不是使用低级语言。较低级别编写代码会花费更多时间，需要更多的内存操纵的专业知识，结果可能会引入错误。因此，对于程序员来说，能够以一种熟悉的语言为区块链应用程序编写有效、经过测试和错误检查的代码，而不损害底层受限脚本语言提供的安全性，将是有利的。

如本公开中所描述的方法和系统使得能够开发“SDK”以用于创建专门的区块链交易或交易集群。例如，交易可能目的是自动执行机器可执行智能合约的条款和条件，然而许多其他应用也是可能的，并且本发明在这方面不受限制。因此，本发明可以形成用于创建和测试与区块链相关的技术的“工具箱(toolkit)”或系统的一部分。

有利的是，区块链编译器执行用户源代码的静态编译，并使得能够通过使用诸如循环展开之类的技术来实现复杂的控制流机制。如本领域中已知的，“循环展开”也可以被称为“循环解开”。循环展开是一种循环转换技术，编译器可以使用它来减少某些类型的循环中分支的频率和/或减少循环维护指令。通过展开源代码中的循环，编译器可以生成源代码的转换版本，该版本可以在使用功能受限的脚本语言的区块链平台上执行。

转到图1，本公开的实施方式使得用户(程序员)能够使用高级语言(HLL)来针对期望的应用(例如智能合约)限定代码101，然后执行区块链编译器102，编译器102将HLL代码101编译为可执行文件。这些可执行文件可以是可由机器人执行的3G语言程序块(例如python、C++等)的形式，或可以是(例如比特币)脚本103块的形式。后者通过设计和生成可以执行特定功能的脚本块来实现。例如，原始版本的比特币脚本包括称为OP_MUL的乘法功能。此操作码当前已禁用。然而，可以通过在脚本的一小部分中使用已启用的现有操作码来重新创建相同的功能。

本公开的实施方式可以包括两种原语中的一种或两种：

·定制的操作码(在下文中，将其称为COP_CODE)；和

·高级语言(HLL)结构

HLL结构要求编译器102将其转换为脚本代码103，而COP_CODE仅需要从COP_CODE到OP_CODE块的直接替换。通常，如果原语不需要访问任何变量，即仅使用区块链脚本语言中针对给定协议已存在的OP_CODE(以及其他COP_CODE)和硬编码输入就可完整描述原语，则原语被直接制成COP_CODE。

例如，monus原语可使用操作码充分描述且可被制成COP_CODE，如下所示：

OP_SUB

OP_0

OP_MAX

然而，WHILE循环的执行取决于所需的变量(例如，执行条件；迭代次数的计数器；等等)。因此，WHILE不适合制作为COP_CODE，而是将其编写为HLL结构。

有利的是，包含两种原语为程序员提供了额外的灵活性。将程序直接编写到比特币脚本(即不使用HLL)中的程序员将能够通过COP_CODE使用增强的脚本功能。实际上，这些为脚本程序员提供了OP_CODE块的替代品，其将执行所需的功能，这减少了编程时间和工作量。所需要的只是“COP-CODE编译器”，其仅用构成它的OP_CODE块替换COP_CODE。不能或不愿意以低级比特币脚本编写程序的程序员能够改为使用本公开所支持的HLL。

下面进一步讨论定制的OP_Code(COP_Code)。

1.定制的OP_CODE(COP_CODE)

本部分描述了下文可应用的标准，该标准是根据本公开与针对定制的OP_CODE(COP_CODE)的脚本原语有关的标准。COP_CODE的格式与常规操作码相似，并且以相同的方式操作。也就是说，脚本(和/或编译器)的编写者使用原语的方式与传统上使用操作码的方式相同。比特币操作码列表可在比特币维基百科：https：//en.bitcoin.it/wiki/Script上得到。

命名规范

在此以类似于比特币脚本操作码的方式对脚本原语进行命名，如下所示：

COP_xxx

其中“xxx”是该功能的简写。例如，一个乘法功能可以被命名为：COP_MULT。此外，类似于操作码，如果功能具有特定数量的参数或计算中使用的特定数量，则名称可以包含该数字。例如，操作码“OP_2DROP”表示“删除前两个堆栈项目”，而“OP_1ADD”表示“将1添加到输入中”。因此，COP_2MULT可专门表示“输入乘以2”。

执行前的验证

如果预期特定数目的输入或输入格式，则原语在执行功能逻辑之前执行检查，如果输入与预期不符，则中止(将交易标记为无效)。有利地，这防止了执行并提供可能不正确或误导的输出的功能。例如，如果特定原语仅打算在为正数的输入上操作，然而仍然无错误地对负数执行，则结果可能是带有非预期或不正确结果的“有效交易”。

2.高级语言(HLL)结构

这些是根据本公开排列的编译器能够识别并能够转换成比特币脚本的功能或语句。所有这些共同构成了使用程序员熟悉的语法的高级编程语言。除了熟悉的结构(例如IF-ELSE，CASE，WHILE循环等)之外，由于比特币交易的工作方式，还有一些不熟悉的HLL非常特定结构。例如，INITIATE结构执行非常特定的功能，即确保自动推入主堆栈的数据输入的数量被保存为内存分配中的第一个常量(分配给保留字NUM_INPUTS)。在实施方式中，INITIATE结构可以是HLL程序中的第一个语句，而DECLARE结构(其为常量和变量执行内存分配)可以是HLL程序中的第二个语句。

必须以如下方式设计HLL结构，使得编译器仅使用编译时可用的信息将其转换为比特币脚本(即，转换为OP_CODE和COP_CODE)。这通常意味着程序员需要进行大量的硬编码，其中常量在DECLARE中被声明且在程序中被赋值。例如，即使NUM_INPUTS被认为是一个常量，编译器在程序执行之前也无法访问其值，因此不能将其用于编译执行(然而，当然程序员可以在程序中像任何其他常量一样使用它)。

在设计HLL结构时，设计人员可以使用伪代码或自然语言的清晰说明来包含编译器的预期操作。例如，可能要求编译器执行某些检查-例如正确的语法和验证是否符合任何约束(例如大小限制)。这一点应明确，即使可能尚不知道具体的约束。设计HLL结构这一任务不包括编写编译器本身，而必须确保可以进行编译器的所有预期操作。

现在提供可以根据本公开的示例性实施方式使用的一系列HLL结构。

HLL结构：While循环

描述

只要指定条件保持为True，就会重复执行代码块(block ofcode)(或代码块(code-block)，通常称为循环主体)，直至最大迭代次数。必须在编译时知道并指定最大迭代次数。通过称为“展开循环”的技术来模拟循环。这意味着将表示代码块功能(操作顺序)的一系列操作码被复制了指定的最大迭代次数。在针对代码块的每个复制的操作码序列之前的IF语句确定是否执行代码块的操作码序列。在循环开始时(即在第一次执行代码块的操作码序列之前)检查IF条件。

语法：

WHILE(Iterations,Condition)

<CODE-BLOCK>

END_WHILE

其中：

迭代次数：

正整数

代码块可以执行的最大次数。编译器需要知道该值，因为它将生成代码块直至该许多次。其可以是硬编码的，或可以引用DECLARE语句中的常量。

条件：

可解析为TRUE(真)或FALSE(假)的可评估表达式

可以是复合条件-即使用AND，OR等(以编译器当前识别的为准)

编译器操作：

执行语法检查。

检查迭代是否满足任何约束(例如，落在规定范围内)

检查Condition中的表达式为可评估的：

表达式中的所有常量/变量都存在于内存分配(DECLARE)列表中

检查在表达式中使用的所有运算符当前都被允许(＝，<，>等)

检查复合表达式满足任何约束(例如，有限的AND，OR等)

将代码块的功能负载“迭代次数”次：

开始复制的代码

编写一个或更多个解析该条件的操作码(即，该操作码的执行在堆栈顶部留下TRUE或FALSE)：

常规过程可以使用RETRIEVE结构，该结构获取测试所需的每个值并将该值放置在主堆栈的顶部；然后执行相关的测试操作(即OP_EQUAL，OP_LESSTHAN，OP_GREATERTHAN等)。如果要测试的值是常量，则它将位于分配的内存中的已知位置(即主堆栈上的已知位置)，并将使用OP_PICK被复制到堆栈的顶部。如果要测试的值是变量(在该情况下，要测试的值在脚本执行期间被确定)，则该变量的位置将位于分配的内存中的已知位置(即，在alt堆栈上的已知位置)，且可以使用“借用块”方法被复制到主堆栈的顶部。

如果测试采用复合条件(使用AND，OR等)，则将分别评估每个子条件，并将最终结果(0或1)保留在主堆栈顶部。这些然后被组合以测试复合条件。例如，如果复合条件的形式为“Exp1OR Exp2”：操作首先评估Exp1，然后评估Exp2，然后编写OP_BOOLOR，其将比较堆栈上的前两个值(即Exp1和Exp2的评估结果)。

评估结果留在主堆栈的顶部。堆栈上没有其他值(当然，分配的内存除外)。该值将由下一个操作(OP_IF)使用。

将代码块的功能(操作顺序)转换为代表代码块功能的操作码序列。对于代码块中包含的任何COP_CODE，都可以绕过该转换，其仅需要将COP_CODE直接代入代码块的操作码序列中即可。然后，编写代表OP_IF/OP_ENDIF对中代码块的功能的操作码序列。

结束复制的代码

在一些实施方式中，代表复制的代码块的操作码序列可以被配置成使得：针对WHILE循环结构的每个迭代由操作码序列访问的常量和变量的初始堆栈位置在循环迭代中恒定。注意，变量的值可在循环迭代中更新；然而，在开始执行每个循环迭代时该常量和变量的堆栈位置将在循环迭代期间保持恒定。该操作确保了复制的操作码序列在每个循环迭代期间访问存储在堆栈上的适当的常量和/或变量。

在一些实施方式中，复制代码块的条件可取决于在脚本执行期间确定的一个或更多个变量的值，且因此可在循环迭代中更新。在这种情况下，复制的代码块的每个迭代可以包括测试相关条件的一个或更多个操作码命令，随后是代表嵌入在OP_IF/OP_ENDIF对中的复制的代码块的操作码序列。在此配置中，在脚本执行期间，测试相关条件的操作码命令将评估为TRUE或FALSE并将TRUE或FALSE结果放置在堆栈顶部。仅当TRUE结果位于堆栈顶部时，以下OP_IF语句的执行才会选择性地执行复制的代码块。因此，当FALSE结果位于堆栈顶部时，执行OP_IF语句将绕过执行复制的代码块。

此外，复制代码块的条件可以受到最大迭代次数的限制，最大迭代次数可以由WHILE循环结构中指定的参数、系统设计所固定的参数或其他一些参数来定义。在这种情况下，对条件进行测试的操作码命令以及随后的表示嵌入在OP_IF/OP_ENDIF对中的已复制代码块的操作代码序列可被复制多次，该次数与上述参数定义的最大迭代次数相对应。

还要注意，HLL程序可以使用嵌套的WHILE循环结构，其中内部WHILE循环结构包含在外部WHILE循环结构的代码块中。在这种情况下，编译器可以结合外部WHILE循环结构的循环展开来对内部WHILE循环结构进行循环展开。例如，内部WHILE循环结构的循环展开可以在一对OP_IF/OP_ENDIF字节码指令之间复制表示内部WHILE循环结构的代码块的功能的操作码序列，复制次数为内部WHILE循环结构的迭代次数。此外，外部WHILE循环结构的循环展开可以在一对OP_IF/OP_ENDIF字节码指令之间复制表示外部WHILE循环结构的代码块的功能的操作码序列，复制次数是外部WHILE循环结构的迭代次数。在这种情况下，表示针对外部WHILE循环结构的每个迭代的代码块的功能的操作码序列包括针对内部WHILE循环结构的迭代次数的操作码序列。

还要注意，可以扩展WHILE循环嵌套，其中在内部(第一内部)WHILE循环结构的代码块内包含另外的内部WHILE循环结构，且具有可能的另外的嵌套。在这种情况下，在此所述的循环展开操作可容易地扩展以解决该进一步的嵌套。

HLL结构：INITIATE

描述：

在实施方式中，这是任何HLL程序的强制性第一语句。

交易耗用方提供的脚本执行的第一部分(即“脚本签名”)不在解锁脚本的控制范围之内。它通常包括将被推入堆栈的数据。INITIATE结构的目的是使程序员能够管理此输入(不管脚本其余部分是否需要，最可能的是需要)。

此结构为保留字NUM_INPUTS(其为耗用方提供的输入中被推入堆栈的项目数)“分配值”。第一个OP_CODE将始终为OP_DEPTH，以便堆栈的顶部(此时)包含已推入堆栈的数据输入的数量。堆栈中的此位置将是固定的，并且在编译时会被编译器知道，尽管在编译时不会知道实际值。

语法：

INITIATE

编译器操作：

Write OP_DEPTH/*这会将OP_DEPTH设置为NUM_INPUTS的值

HLL结构：DECLARE

描述：

在实施方式中，这是任何HLL程序的强制性第二结构。

声明所有常量和变量，以便编译器可以保留“内存存储空间”(即主堆栈和/或alt堆栈中的位置)。标准是在主堆栈上保持常量，在alt堆栈上保持变量。编译器会将赋予变量和常量的名称与其在堆栈中的位置相关联。编译器会将已命名的项目推入主堆栈，该主堆栈已包含耗用方提供的数据输入(请参见INITIATE)以及在其顶部处表示这些数据项的数目的值(其与保留字NUM_INPUTS关联)。

语法：

编译器操作：

编写PUSHDATA命令，以将HLL程序的被声明的常量值放入内存存储(例如主堆栈)中。这些命令可以从顶部开始，且将项目逐一推到内存存储中。编译器可以跟踪内存存储中每个常量值的位置(例如主堆栈位置)。

编写OP-TOALTSTACK命令，以将HLL程序的变量放入内存存储中(例如alt堆栈)。再次，编译器可以跟踪内存存储中每个变量的位置(例如，alt堆栈位置)。

示例：

在编译器执行完这些语句之后(并假设强制性的INITIATE语句将获取一些值)，内存存储的状态(在这种情况下，主堆栈和alt堆栈)将如下所示：

在此示例中，假设存在提供给解锁脚本的一些输入项目。至少，在标记为“NUM_INPUTS”(这是一个保留字)的位置上将有一个值，即使该值为0且其下方的堆栈中也没有值。该值将被视为存储块的开始，其与下面有多少项目无关。编译器知道内存中项目的数目以及其与堆栈顶部开始的初始相对位置。这些项目在程序执行期间将保持位置不变。使用堆栈顶部上的空间(图中示为“(用于临时变量)”)完成临时计算。当项目被临时推入主堆栈顶部上以进行计算时，这改变了内存项目的相对位置。然而，编译器将始终保持有关于相对位置的知晓。

例如，在执行了DECLARE语句之后，编译器将计算并在内部保持Init-depth(初始深度)的值(在示例中，Init-depth＝12)以及堆栈中针对每个项目的深度位置。即：

Init-depth-Num_Hashes＝5

Init-Depth-NUM_INPUTS＝12

Init-Depth-Stock[i]＝11–i+1

编译器将能够根据<项目的初始深度>+<添加到堆栈中的项目数目>来计算编译过程中任何时候任何项目的深度。

HLL结构：INCREMENT

描述：

变量将从其在内存中的位置中被检索，加1；然后在内存中在其位置处被替换。

语法：

INCREMENT(Variable-name)

其中：

变量名：

声明部分中使用的名称，用以标识变量。

编译器操作：

注意：编译器保持关于两个堆栈上不同项目数目的知晓(比如Main_Stack_Height和ALT_Stack_Height()。编译器还知道在每个堆栈上每个变量和常量的位置，该位置是在Declaration部分确立的，即Var-Posn＝alt堆栈中变量名称的位置(即从堆栈底部向上项目的数目)。

该操作使用借用块(Borrow Block)技术。

计算Var-Depth＝ALT_Stack_Height-Var-Posn+1

Write OP_FROMALTSTACKVar-depth times/*使所需的变量到主堆栈顶部

Write OP_ADD1/*将值加1

Write OP_TOALTSTACKVar-depth(变量深度)次数/*将所有借来的变量替换回alt堆栈

(参见借用块描述中的示例2)

示例:增加变量B

任务是增加变量B。编译器知道B在alt堆栈中的深度为：B-Depth(B深度)＝5。编译器生成以下脚本代码：

HLL结构:IF ELSE

描述:

标准IF测试

语法:

其中:

Value1硬编码的值或变量名称或常量名称

Value2硬编码的值或变量名称或常量名称

测试操作数学测试运算符比如“＝”、“<”、“>”、“≤”、“≥”等。

编译器操作：

检查语法。包括：

将测试操作与等同操作码(内部表)匹配：

HLL结构:RESET

描述:

变量被赋予指定的值。

语法:

RESET(Variable-name,Reset-value)

其中：

Variable-name被赋予新值的变量的名称

Reset-value赋予Variable-name的值

编译器操作：

注意：编译器保持关于两个堆栈上不同项目数目的知晓(比如：Main_Stack_Height(主堆栈高度)和ALT_Stack_Height(ALT堆栈高度))。编译器还知道每个变量和常量在分配的内存(即在每个堆栈上)中的位置，该位置是在DECLARE部分确立的。

假设Var-Posn(变量位置)＝变量名称在alt堆栈中的位置(即从堆栈底部向上的项目的数目)。该操作使用借用块技术：

计算Var-Depth＝<当前ALT_Stack_Height>-Var-Posn+1

HLL结构：ABORT

描述：

将交易标记为无效

语法：

ABORT

编译器操作：

Write OP_0OP_VERIFY

HLL结构：POPULATE

描述：

该结构的目的是使用交易耗用方的输入(比如通过执行耗用交易的解锁脚本所提供的输入)填充程序员声明的常量。

锁定脚本的输入(即“脚本签名”)会将任何数据推到主堆栈上。这发生在DECLARE结构之前，因此这些输入在堆栈底部。堆栈项目的数目(NUM_INPUTS(输入的数目))通过(强制性)INITIATE语句被放在它们的上面。程序员的责任是验证交易规则得到满足(例如提供了正确的输入的数目)。

语法：

POPULATE(Stack-position，Constant-name)

其中：

Stack-position：

整数。从存储块底部开始向下计数的位置。请记住，内存块的底部始终包含项目NUM_INPUTS(输入的数目)，在此之下是在执行锁定脚本代码之前被推到堆栈上的输入数据。

Constant-name：

要填充的常量的名称。

编译器操作：

计算shift-count＝要临时从主堆栈移到alt堆栈以安全保管的堆栈项目的数目：

shift-count＝目标项目上方的堆栈项目的数目(常量名称)

计算Input-depth＝<Constant-name的相对高度>+stack-position Write:

HLL结构：RAWSCRIPT

描述：

代表比特币脚本代码的有效块的值数组。编译器将首先验证数组，以确保它是脚本代码的有效块(包括OP_CODE，COP_CODE和整数)。

目的是允许程序员将低级代码直接包含到编译器输出中。这对于比使用当前可用的HLL结构更容易直接编码到脚本代码中的任何功能都是有用的。

语法:

RAWSCRIPT[Values]

其中:

Values OP_CODE,COP_CODE的数组(列表)以及其整数输入

编译器操作：

编译器首先验证值的集合一起构成有效的比特币脚本。也就是说，OP_CODE都是当前接受的启用的OP_CODE的一部分，COP-CODE都存在于COP_CODE词典中，并且都具有预期的输入值。

接着，编译器仅将值写出到输出脚本中的当前位置中。

HLL结构：CALCULATETEMP

描述：

进行了有效的计算，将结果放置在主堆栈的顶部。“有效”表示它是HLL当前可用的功能结构之一。程序员必须编写程序，以便在以后引用时TEMP可用(即仍在堆栈顶部)。请注意，TEMP只能被引用一次。(如果需要多次，则应在DECLARE中将其声明为变量。)

语法：

CALCULATE TEMP＝expression

编译器操作：

检查该expression有效(是当前可用功能结构列表的成员)。

执行表达式，将结果(TEMP)放在堆栈顶部。

解析以下对TEMP的引用–确定在引用时TEMP是否确实在堆栈的顶部：如果不在，则抛出编译错误。

示例:

CALCULATE TEMP＝HASH160(123456789)

HLL结构：HASH160

描述：

其执行与OP_CODE等同的哈希算术：OP_HASH160

语法:

HASH160(value1)

其中：

value1是以下任一：

硬编码的整数

声明的常量

声明的变量

编译器操作：

如果value1是硬编码的数，其被推到堆栈顶部

如果value1是变量或常量，则被检索(推到堆栈顶部)

编译器编写：

OP_HASH160

HLL结构：RETRIEVE

描述：

变量或常量将从其在内存中的位置被检索，并被复制到主堆栈的顶部。原始值将在“内存”中其当前位置处保持不变。

语法：

RETRIEVE(Item-name)

其中：

Item-name声明的变量或常量

编译器操作：

注意：编译器保持关于两个堆栈中不同数量项目的知晓(例如：Main_Stack_Height(主堆栈高度)和ALT_Stack_Height(ALT堆栈高度))。编译器还知道每个变量和常量在每个堆栈中的位置，其在Declaration部分中被确立，即Item-posn＝项目名称在堆栈中的位置(即，从堆栈底部向上的项目数目)。该操作使用借用块技术。

计算Item-Depth＝Stack_Height-Item-posn+1

如果所需的项目在alt堆栈中(即是变量)

示例：检索变量C的副本

假设内存分配看起来如下：

任务是将变量C的副本放置到主堆栈顶部。编译器知道alt堆栈中C的深度是：Item-Depth＝4。编译器生成以下脚本代码：

保留字

保留字：NUM_INPUTS(输入的数目)

描述：

这始终是存储块的底部常量。即它是已分配堆栈位置块中的“第一”项。尽管它是常量，然而在编译时不是已知的。因此，编译器不能将其用于任何硬编码的脚本操作(例如，它不能用作对在编译的代码中生成多少OP_TOALTSTACK语句进行计数的数字)。它在执行时是已知的，因此程序员或编译器可以将其用于诸如Loops和IF语句中的条件测试之类的任务。

保留字：TEMP

描述：

这是临时的一次性变量，在计算之后将留在堆栈顶部。它的存在使程序员能够在计算中引用它。稍后在程序中引用TEMP时，编译器将检查语法以确保TEMP仍位于堆栈的顶部。

保留字：CONSTANTS

描述：

它与DECLARE结构一起使用。它后面是将被推到主堆栈的常量列表。

保留字：VARIABLES

描述：

它与DECLARE结构一起使用。其后是将被推到alt堆栈的变量列表。

为了便于说明，现在提供一个涉及WHILE循环的用例示例，一个示例HLL程序以及将从中编译的比特币脚本代码。比特币脚本代码使用属于比特币脚本语言Script的操作码。请注意，比特币脚本代码包括注释，注释以常规方式以/*或//开头。这些注释不必是编译器生成的比特币脚本代码的一部分，以下包括这些注释是为了说明编译器在生成示例性比特币脚本代码中的操作。

While循环示例–交易(Tx)

考虑具有10个硬编码哈希难题的内部列表的区块链交易(Tx)。为了解锁Tx的输出，耗用方需要提供至少3个正确的哈希解决方案。交易锁定脚本将在同一输入(即“脚本签名”中)接受达12个try，并且它们可以是按着任意顺序的。交易将对每个输入“try”进行哈希处理，并检查其是否与内部存储的哈希值之一匹配。

为了清楚起见，请考虑在比特币交易的输入部分中描述解锁脚本的传统方式：

第一部分<scriptSig>是耗用交易中包含的数据和/或OP_CODE，以解锁耗用的前一个交易的输出。第二部分<scriptPubkey>是耗用的前一个交易的输出中使用的锁定脚本。

将这些称为：

假设耗用耗用方输入为TRY1TRY2TRY3TRY4TRY5

也就是说，根据上面指定的规则，耗用耗用方尝试了5个不同的可能哈希方案，其中为了解锁交易仅需要3个是正确的。当执行组合的<Spender Input><locking script>时，第一个操作将是<Spender Input>中的内容，其在此示例中是仅将5个数据项推入堆栈。

锁定脚本逻辑-伪代码

注意：将有嵌套的WHILE循环

标准第一步骤：计数输入的数目并保存为NUM_INPUTS

声明将在脚本中使用的变量和常量，并初始化已知的值：

以耗用方的输入值填充内部数组(即，在该例子中，将Try[1]-Try[5]赋予输入值TRY1、TRY2、TRY3、TRY4和TRY5)。数组的其余部分保持为值零。

将交易标记为有效

正式HLL程序

以下代码是以使用根据本公开实施方式的语法的HLL编写的。旨在于示出WHILE的使用，然而出于必要性也包含其他HLL结构(以大写字母写下)，其中一些已在上面进行了详细介绍，然而本领域技术人员容易理解这些HLL结构，因为其是传统现代高级语言使用的熟悉结构。

编译的比特币脚本

/*INITIATE

OP_DEPTH//确定NUM_INPUTS(保留字)且将其放在堆栈顶部

/*DECLARE CONSTANTS。初始化常量并将其放在主堆栈上。编译器知道常量的位置；12个值的数组(这些是“try值”-稍后会被实际输入值填充)

实际上是数组：Try[12]

OP_0OP_0OP_0OP_0OP_0OP_0OP_0OP_0OP_0

OP_3//Correct_Needed-解锁TX所需的正确哈希命中的数目被硬编码为3

OP_10//Num_Hashes-数组中哈希的数目被硬编码为10

/*硬编码的哈希值被存储到主堆栈上(即将接下来的20个字节推到堆栈上)。实际上是数组HASH-SAVED[10]。

20HASH-SAVED1

20HASH-SAVED2

20HASH-SAVED3

20HASH-SAVED4

20HASH-SAVED5

20HASH-SAVED6

20HASH-SAVED7

20HASH-SAVED8

20HASH-SAVED9

20HASH-SAVED10

/*DECLARE变量初始化变量(索引和布尔逻辑)，并将其放到Alt堆栈上。编译器知道位置。

OP_0OP_TOALTSTACK//Correct_Counter-正确命中的数目(在得到哈希匹配时)

OP_0OP_TOALTSTACK//Try_counter-外部循环的索引：输入值的计数器被尝试

OP_0OP_TOALTSTACK//Hash_counter-内部循环的索引：哈希的计数器被尝试

OP_0OP_TOALTSTACK//Match_found-布尔逻辑标记-在得到哈希匹配时设为True

/*在这个阶段Alt堆栈已被填充，且用作变量的内存存储。编译器将需要“跟踪”变量的位置-即其在alt堆栈上的“深度”。主堆栈已填充有常量。编译器也需要跟踪其位置。主堆栈内存块的“第一个值”被视为NUM_INPUTS的位置(不管下面有多少项目)。

/*在该阶段，编译器知道NUM_INPUTS的值在主堆栈中深度27处。下面的操作将该值复制到堆栈的顶部。然后，其将值“12”推到堆栈的顶部并使用“>”来比较。如果NUM_INPUTS>12(其对应于所允许的最大12个“try”)，则中止。操作可使用OP_DROP，因为OP_VERIFY将结果留在了堆栈顶部。

27OP_PICK OP_12OP_GREATERTHAN OP_VERIFY OP_DROP

/*填充Try[]数组。注意：用于填充Try[]数组的代码块已被移到图2，以提高本申请的清晰性和可读性。假设编译器写出脚本代码快，该脚本代码块将读取Tx输出的耗用方提供的输入值并使用它们来填充Try[]数组。在一个示例中，提供有仅5个输入(即5个“try”)，因此仅Try[]的前5个元素被填充，且其他元素保持值0。

/*外部WHILE循环。可能的最大迭代次数为12(例如，按照预定义的规则)，因此，编译器将通过复制以下操作码序列12次来展开外部WHILE循环。

/*条件1的借用块：“是否Try_counter<NUM_Inputs AND Correct_counter<Correct_Needed？”要在条件1下进行测试，我们需要从Alt堆栈中提取变量；执行测试，然后将变量重新放回(“借用阻止”)。

/*首先获取Try_counter的副本，并将其放在堆栈的顶部。

OP_FROMALTSTACK

OP_DUP

OP_4OP_ROLL

OP_TOALTSTACK

/*然后，得到NUM_Input的副本并放在堆栈顶部上；编译器知道该常量当前在主堆栈的深度14处。

OP_14OP_PICK

/*现在针对条件1的部分1比较两个顶部堆栈项目；这检查“Try-Counter<NUM_Inputs？”且将结果留在堆栈顶部上。

OP_LESSTHAN

/*做条件1检查的部分2(“Correct_counter<Correct_Needed？”)。将结果留在堆栈顶部。

/*首先得到Correct_counter的副本，放在堆栈顶部。

OP_FROMALTSTACK

OP_DUP

OP_5OP_ROLL

OP_TOALTSTACK

OP_13OP_PICK//将Correct_Needed复制到堆栈顶部：编译器知道该常量当前在深度13处。

OP_LESSTHAN//针对条件1的部分2比较两个顶部堆栈项目；这检查“Correct_counter<Correct_needed？”并将结果留在堆栈顶部。

OP_BOOLAND//这完成条件1组合检查：条件1检查的两个部分的结果在堆栈顶部。在该op之后，条件1测试的最终结果在堆栈顶部。其通过以下IF被弹出。

OP_IF

/*用于增加Try-Counter的借用块。第一步是使其到达主堆栈的顶部。编译器知道其在alt堆栈上的深度(在该情况下深度＝3)。

OP_FROMALTSTACK

OP_ADD1

OP_TOALTSTACK

/*用于复位Hash_counter＝0的借用块。编译器知道该变量的位置

OP_FROMALTSTACK

OP_DROP OP_0

OP_TOALTSTACK

/*用于复位Match-Found＝FALSE的借用块。编译器知道该变量的位置。

OP_FROMALTSTACK

OP_DROP OP_FALSE

OP_TOALTSTACK

/*将所需的“Try”值复制到堆栈顶部并对其进行哈希处理

<Try-depth>OP_PICK

OP_HASH160//在正式HLL中这是TEMP的值，留在堆栈顶部。进一步的操作将更多的值推到主堆栈上且从主堆栈弹出更多的值。意图是当接着需要TEMP的值时(用于相等检查)，其将会在堆栈顶部。编译器可以在编译时对此验证，因为编译器可以基于正式HLL代码一直跟踪在堆栈中有什么。

/*内部WHILE循环

/*内部WHILE循环被执行Num_Hashes迭代次数，该迭代次数在给定示例中具有最大值10。因此，编译器将通过在外部WHILE循环的每个迭代内复制以下操作码序列Num_Hashes迭代次数(小于或等于10个迭代次数)来展开内部WHILE循环。

/*针对条件2的借用块：“Match_Found＝FALSE AND Hash-Counter<NUM_Hashes？”。为了进行条件1中的测试，需要从Alt堆栈提取变量；执行测试，且然后将变量再次放回(“借用块”)。

/*首先针对条件2的部分1得到变量Match_Found的副本，且将其放置在堆栈顶部上。编译器知道该变量的位置。

OP_FROMALTSTACK

OP_DUP

OP_2OP_ROLL

OP_TOALTSTACK

/*检查Match_Found＝FALSE且将结果放在堆栈顶部

OP_NOT

/*现在针对条件2的部分2得到变量Hash_countr和NUM_Hashes的副本(测试是否Hash_Counter<NUM_Hashes)。编译器知道三个变量的位置

OP_FROMALTSTACK

OP_DUP

OP_3OP_ROLL

OP_TOALSTACK

OP_13OP_PICK

/*检查Hash_Counter<NUM_Hashes

OP_LESSTHAN

/*完成条件2组合检查：条件2检查的两个部分的结果在堆栈顶部。在该op后，最终结果留在堆栈顶部。

OP_BOOLAND

/*条件2测试的结果在堆栈顶部。其通过以下IF被弹出。

/*内部WHILE循环结束。

/*检索NUM_INPUTS的操作码

/*检查NUM_INPUTS≥1的操作码

OP_IF

用于内部WHILE循环第二次迭代的操作码序列的复制品

END_IF

/*用于检查NUM_INPUTS≥2的操作码

OP_IF

用于内部WHILE循环第三次迭代的操作码序列的复制品

END_IF

/*用于检查NUM_INPUTS≥3的操作码

OP_IF

用于内部WHILE循环第四次迭代的操作码序列的复制品

END_IF

/*用于检查NUM_INPUTS≥4的操作码

OP_IF

用于内部WHILE循环第五次迭代的操作码序列的复制品

END_IF

/*用于检查NUM_INPUTS≥5的操作码

OP_IF

用于内部WHILE循环第六次迭代的操作码序列的复制品

END_IF

/*用于检查NUM_INPUTS≥6的操作码

OP_IF

用于内部WHILE循环第七次迭代的操作码序列的复制品

END_IF

/*用于检查NUM_INPUTS≥7的操作码

OP_IF

用于内部WHILE循环第八次迭代的操作码序列的复制品

END_IF

/*用于检查NUM_INPUTS≥8的操作码

OP_IF

用于内部WHILE循环第九次迭代的操作码序列的复制品

END_IF

/*用于检查NUM_INPUTS≥9的操作码

OP_IF

用于内部WHILE循环第十次迭代的操作码序列的复制品

END_IF

/*结束外部WHILE循环

用于外部WHLE循环的第二次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第三次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第四次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第五次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第六次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第七次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第八次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第九次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第十次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第十一次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

用于外部WHLE循环的第十二次迭代的操作码序列的复制品(包括用于NUM_INPUTS迭代次数(直达10个)的内部WHILE循环的操作码序列的复制品)

/*在完成12个迭代次数的外部WHILE循环时，编译器检查是否得到了所需次数的命中(即，检查Correct_counter≥Correct_Needed)

OP_FROMALTSTACK//到主堆栈顶部检索Correct_counter

OP_FROMALTSTACK

OP_FROMALTSTACK//将Correct_Needed复制到堆栈顶部

OP_12OP_PICK

OP_GREATERTHAN

//该最终操作将测试结果留在堆栈顶部。如果为TRUE(即如果Correct_counter≥Correct_Needed)且可能其他检查通过，则交易被标记为有效。

在实施方式中，区块链编译器可以被配置为至少一次优化输出脚本，以提供输出脚本的更有效或更简化的版本。这可能涉及使用无导数优化(DFO)。DFO是本领域已知的并且为本领域技术人员容易理解的术语。附加地或可替代地，生成输出脚本的步骤可以包括使用无导数优化。

在实施方式中，区块链编译器可以被布置成形成软件开发工具包(SDK)的一部分和/或结合软件开发工具包(SDK)一起操作。该SDK可以包括编辑器、调试器和已知与SDK一起使用的其他组件，以促进基于代码的解决方案的生成。

图3示出了根据本公开的实施方式的与区块链相关联的示例区块链网络1000。在该实施方式中，示例性区块链网络1000包括运行区块链协议的实例的点对点分布式电子设备。在一些示例中，分布式电子设备被称为节点1002。区块链协议的示例是比特币协议。

节点1002可以由任何合适的计算设备(例如，由数据中心中的服务器，由客户端计算设备(例如，台式计算机、膝上型计算机、平板计算机、智能手机等)，由计算资源服务提供商的分布式系统中的多个计算设备，或由任何合适的电子客户端设备比如图5的计算设备2600)组成。

在实施方式中，一个或更多个节点1002通信地耦合到一个或更多个其他节点1002。这种通信耦合可以采用众所周知的有线或无线通信链路中的一个或更多个。在该实施方式中，节点1002每个都维护区块链中所有交易的“账本”的至少一部分。以这种方式，账本是分布式账本。由影响账本的节点处理的区块链交易由一个或更多个其他节点进行验证，从而维护账本的完整性。

在实施方式中，至少一些节点1002是矿工节点，其执行涉及复杂计算(例如求解加密问题)的采矿过程。求解加密问题的矿工节点为区块链创建新区块，并将该新区块广播到节点1002中的其他节点。节点1002中的其他节点执行验证过程，该过程验证矿工节点的工作，并且在验证后，将区块接受到区块链中(例如，通过将其添加到区块链的分布式账本中)。在一些示例中，区块是一组交易，通常用前一个区块的时间戳和“指纹”(例如，哈希)标记。通过这种方式，每个区块都链接到前一个区块，从而创建了在区块链中链接区块的“链”。在实施方式中，通过节点1002的共识将有效块添加到区块链。此外，在一些示例中，区块链包括经过验证的区块的列表。

在实施方式中，节点1002中的至少一些用作验证节点，其执行如本公开中所述的对交易进行验证的验证过程。图3示出了标记为1004的一个示例性交易。在一些示例中，交易包括如下数据，该数据提供数字资产所有权(例如，一定数量的比特币令牌)的证明以及用于接受或转移数字资产所有权/控制的条件。在一些示例中，“耗用交易”指的是如下交易：该交易将前一个交易的未耗用交易输出(UTXO)指示的至少一部分数字资产重新关联(例如，转移所有权或控制权)到与区块链地址相关联的实体。在一些示例中，“前一个交易”是指包含耗用交易所引用的UTXO的交易。在一些实施方式中，交易可包括“解锁脚本”和“锁定脚本”。锁定脚本可用于以如下条件来妨碍交易：该条件必须在交易被验证以及所有权/控制权通过交易转移之前被满足。在一些实施方式中，锁定脚本可与交易的输出相关联，且可被配置成限定耗用输出所需的一个或更多个条件。此外，耗用交易的解锁脚本可被配置成使得解锁脚本的执行提供如下数据：该数据用于得出一组条件，该一组条件被前一个交易的锁定脚本的执行评估，用于验证耗用交易。前一个交易的锁定脚本和耗用交易的解锁脚本是使用功能受限的低级脚本语言编写的，例如比特币的Script。

在一些实施方式中，对耗用交易的验证可以包括与执行前一个交易的锁定脚本一起执行耗用交易的解锁脚本，以便满足并验证由前一个交易的锁定脚本指示的一组条件。对耗用交易的验证可能涉及其他检查。成功验证耗用交易后，耗用交易可以传播到其他网络节点。矿工节点可以选择将有效的耗用交易嵌入为此处所述的、添加到区块链的区块的一部分。

如图3所示，本文所述的区块链编译器1001用于将HLL程序转换成区块链兼容脚本(或脚本片段)。这可以被称为“输出脚本”，因为它可以形成由区块链编译器1001提供的输出。可以在区块链交易(Tx)中提供输出脚本。它可以是与交易输出关联的锁定脚本的一部分，或与交易输入关联的解锁脚本的一部分。输出脚本可以由从区块链脚本语言所选的、区块链脚本语言固有和/或形成区块链脚本语言的一部分的操作码形成，该区块链脚本语言可由区块链网络的节点执行。操作码可以被称为原语或命令。脚本的操作码可以由在区块链网络1000的节点上运行的解释程序或虚拟机执行。解释程序或虚拟机可以将脚本的操作码转换为机器可执行(对象)代码。区块链脚本语言可以是例如与比特币协议或其变体结合使用的Script语言。脚本语言可以包括加密、算术和堆栈操纵操作码。

编译器1001可以是SDK的一部分，或者可以是在线服务，该在线服务使用静态编译来生成可以由机器人或区块链网络的节点执行的区块链交易脚本(或脚本片段)。

可替代地，本文描述的编译器的方法可以用作机器人或区块链网络的节点的运行时环境的一部分，其中运行时环境将HLL程序的块(例如，以3G语言比如python，C++等编写的程序)解释或动态编译或转换成可以由机器人或区块链网络的节点执行的区块链交易脚本或脚本片段。

图4示出了用于验证和挖掘耗用前一个交易202(标记为“TX1”)的输出的耗用交易204(标记为“TX 2”)的示例性区块链协议。前一个交易202具有包括令牌量(数字资产)和锁定脚本的输出，该锁定脚本被配置为限定耗用令牌量所需的一组条件。前一个交易202已经被验证和挖掘，使得其被嵌入在区块中，然后对该区块进行验证，使得其被存储在区块链208上。耗用交易204包括具有交易输出标识符字段(标记为“Tx输出ID”)和解锁脚本的输入，该交易输出标识符字段指代前一个交易202的输出。前一个交易202的锁定脚本和耗用交易204的解锁脚本使用功能受限制的低级脚本语言来编写，比如比特币的Script。对于视为有效的耗用交易204，输入的解锁脚本必须提供如下数据，该数据满足前一个交易202的被指代输出的锁定脚本限定的一组条件。前一个交易202(或其一部分)的锁定脚本和耗用交易204的解锁脚本可通过在此所述的区块链编译方法和工具生成。

通过执行耗用交易204的解锁脚本以及执行前一个交易202的锁定脚本，由区块链网络的一个或更多个节点(图4)来验证消费交易204，从而满足并验证前一个交易202的锁定脚本规定的一组条件。消费交易204的验证可以涉及其他检查。在成功验证消费交易204之后，可以将耗用交易传播到其他网络节点。矿工节点可执行挖掘操作，该挖掘操作选择并嵌入有效消费交易，作为添加到区块链208的区块的一部分，如本文所述。一旦被验证并存储在区块链208上，交易序列202和204就提供了对交易所引用的令牌量(数字资产)的控制权的转移。

图5是可用于实践本公开的至少一个实施方式的计算设备2600的说明性简化框图。在各种实施方式中，计算设备2600可以用于实现如上所示和所述的区块链网络的区块链编译器和网络节点。例如，计算设备2600可以被配置为用作数据服务器、网络服务器、便携式计算设备、个人计算机或任何电子计算设备。如图5所示，计算设备2600可以包括一个或更多个处理器2602，其可以被配置为经由总线子系统2604与多个外围子系统通信并且可操作地耦合到该外围子系统。处理器2602可以被用于如本文所述将HLL源代码程序编译成区块链脚本(或其片段)。这些外围子系统可包括存储子系统2606(包括存储器子系统2608和文件/磁盘存储子系统2610)、一个或多个用户接口输入设备2612、一个或多个用户接口输出设备2614以及网络接口子系统2616。存储子系统2606可以用于信息的临时或长期存储，信息比如是与本公开中描述的交易相关联的细节。

总线子系统2604可以提供用于使计算设备2600的各个组件和子系统能够按预期彼此通信的机制。尽管总线子系统2604被示意性地示出为单个总线，但是总线子系统的替代实施方式可以利用多个总线。网络接口子系统2616可以提供到其他计算设备和网络的接口。网络接口子系统2616可以用作从其他系统接收数据以及从计算设备2600向其他系统发送数据的接口。例如，网络接口子系统2616可以使数据技术人员能够将该设备连接至无线网络，以使得数据技术员在远程位置(例如用户数据中心)时能够发送和接收数据。总线子系统2604可以用于将诸如细节、搜索项等的数据传送到本公开的监督模型，并且可以用于将监督模型的输出传送给一个或更多个处理器2602，并经由网络接口子系统2616传送给商户和/或债权人。

用户接口输入设备2612可以包括一个或更多个用户输入设备，例如键盘；指向设备，例如集成鼠标、轨迹球、触摸板或图形输入板；扫描仪；条形码扫描仪；装入显示器中的触摸屏；音频输入设备，例如语音识别系统，麦克风；和其他类型的输入设备。通常，术语“输入设备”的使用旨在包括用于向计算设备2600输入信息的所有可能类型的设备和机制。一个或更多个用户接口输出设备2614可以包括显示子系统、打印机或非视觉显示器比如音频输出设备等。显示子系统可以是阴极射线管(CRT)、平板设备例如液晶显示器(LCD)、发光二极管(LED)显示器或投影或其他显示设备。通常，术语“输出设备”的使用旨在包括所有可能类型的设备和用于从计算设备2600输出信息的机制。一个或更多个用户接口输出设备2614可以用于例如呈现用户接口，以便利于用户与执行所述处理和其中变化的应用交互—在这样的交互适当时。

存储子系统2606可以提供用于存储基本编程和数据结构的计算机可读存储介质，该基本编程和数据结构可以提供本公开的至少一个实施方式的功能。当由一个或多个处理器执行时，应用程序(程序，代码模块，指令)可以提供本公开的一个或多个实施方式的功能，并且可以被存储在存储子系统2606中。这些应用程序模块或指令可以由一个或更多个处理器2602执行。存储子系统2606可以另外提供用于存储根据本公开使用的数据的存储库。存储子系统2606可以包括存储器子系统2608和文件/磁盘存储子系统2610。

存储器子系统2608可以包括多个存储器，包括用于在程序执行期间存储指令和数据的主随机存取存储器(RAM)2618以及可以存储固定指令的只读存储器(ROM)2620。文件/磁盘存储子系统2610可以为程序和数据文件提供非暂时性永久性(非易失性)存储，并且可以包括硬盘驱动器，软盘驱动器以及关联的可移除介质，紧凑型盘只读存储器(CD-ROM)驱动器，光盘驱动器，可移除介质盒以及其他类似的存储介质。

计算设备2600可以包括至少一个本地时钟2624。本地时钟2624可以是代表从特定开始日期开始发生的滴答数的计数器，并且可以一体地位于计算设备2600内。本地时钟2624可以用于以特定的时钟脉冲来同步计算设备2600的处理器和其中所包括的所有子系统的处理器中的数据传输，并且可以用于协调计算设备2600与数据中心中的其他系统之间的同步操作。在一实施方式中，本地时钟2624是原子时钟。在另一个实施方式中，本地时钟是可编程间隔计时器。

计算设备2600可以是各种类型，包括便携式计算机设备、平板计算机、工作站或以下描述的任何其他设备。另外，计算设备2600可以包括另一设备，该另一设备可以通过一个或多个端口(例如，USB、耳机插孔、闪电连接器等)连接到计算设备2600。可以连接至计算设备2600的设备可以包括被配置为接受光纤连接器的多个端口。因此，该设备可以被配置为将光信号转换为电信号，该电信号可以通过将设备连接至计算设备2600的端口进行传输以进行处理。由于计算机和网络的不断变化的性质，因此对图13所描绘的计算设备2600的说明仅用作具体示例，用以示出设备的优选实施方式。可以有具有比图5所示更多或更少组件的许多其他配置。

应当注意，上述实施方式说明而不是限制本公开，并且本领域技术人员将能够设计许多替代实施方式而不会脱离由所附权利要求限定的本公开的范围。本公开的方法、系统和装置(或其部分)可以借助于包括若干不同元件的硬件并且借助于适当编程的计算机来实现。在列举若干装置的设备权利要求中，这些装置中的若干个可以由一项且同一项硬件来实现。在互不相同的从属权利要求中记载某些措施这一事实并不意味着不能有利地使用这些措施的组合。

因此，说明书和附图应被认为是说明性的而不是限制性的。然而，很明显，在不脱离权利要求书所阐述的本发明范围的情况下，可以对其做出各种修改和改变。同样，其他变型也在本公开的范围内。因此，所公开的技术可以有各种修改和替代结构，然而其某些示出的实施方式在附图中示出并且已经在上面进行了详细描述。然而，应当理解，无意将本发明限制为所公开的具体形式，相反，本发明旨在涵盖落入本发明范围内的所有修改、替代结构和等同形式，该范围由所附权利要求限定。

在权利要求中，括号内的任何附图标记均不应解释为对权利要求的限制。此外，在描述所公开的实施方式的上下文中(特别是在所附权利要求的上下文中)术语“a”和“an”以及“the”、以及类似指代的使用应被解释为涵盖单数形式和复数形式，除非另有说明或与上下文明显矛盾。除非另有说明，否则术语“包括”、“具有”、“包括”和“包含”应被解释为开放式术语(即，意思是“包括但不限于”)。术语“连接”在没有修改且指代物理连接时，应被理解为部分地或全部地包含在其中、附接到或结合在一起，即使有事物介入其间。在本公开中提到值的范围仅用于分别提到落入该范围内的各个单独值的快捷方式，除非另有说明，且每个单独值被包括在说明书中，就如同其被单独提起一样。术语“集”(比如“项目的集合”)或“子集”应被理解为包括一个或更多个成员的非空集合，除非另有说明或与根据上下文矛盾。此外，术语对应集合的“子集”不必然表示对应集合的适当子集，而是：子集和对应集合可以是等同的，除非另有说明或根据上下文矛盾。元件的单数形式并不排除该元件的复数形式，反之亦然。

除非另有明确说明或与上下文明显矛盾，否则应通过按通常使用的上下文来理解连词语言比如下面形式的短语“A、B和C中的至少一个”或“A、B和C中的至少一个”，从而呈现出：项目、术语等可以是A、B或C，或A和B和C的集合中的任何非空子集。例如，在具有三个成员的集合的说明性示例中，连词短语“A，B和C中的至少一个”和“A，B和C中的至少一个”是指以下任意集合：{A}，{B}，{C}，{A，B}，{A，C}，{B，C}，{A，B，C}。因此，这种连词语言通常不意在表明特定实施方式需要至少一个A、至少一个B以及至少一个C各自都存在。

所描述的过程的操作可以以任何合适的顺序执行，除非另外指出或与上下文明显矛盾。可以在配置有可执行指令的一个或多个计算机系统的控制下执行所描述的过程(或其变形和/或组合)，并且可以将其实现为代码(例如，可执行指令，一个或多个计算机程序或一个或多个应用程序)通过硬件或其组合在一个或多个处理器上共同执行。该代码可以例如以计算机程序的形式存储在计算机可读存储介质上，该计算机程序包括可由一个或多个处理器执行的多个指令。所述计算机可读存储介质可以是非暂时性的。

所提供的任何和所有示例或示例性语言(例如，“比如”)的使用仅旨在更好地阐明本发明的实施方式，并且不构成对本发明范围的限制，除非另有声明。说明书中的任何语言都不应解释为指示任何未要求保护的要素对于实施本发明必不可少。

描述了本公开的实施方式，包括发明人已知用于执行本发明的最佳模式。通过阅读前述说明，那些实施方式的变型对于本领域技术人员而言将变得明显。发明人期望熟练的技术人员适当地采用这样的变型，并且发明人希望本公开的实施方式可以以不同于具体描述的方式来实践。因此，本公开的范围包括适用法律所允许的所附权利要求中记载的主题的所有修改和等同物。而且，除非另外指出或与上下文明显矛盾，否则上述元件在其所有可能的变化中的任何组合都被本公开的范围涵盖。

所引用的所有参考文献(包括出版物、专利申请和专利)均通过引用并入本文，其程度如同：每个参考文献被单独具体指示为通过引用并入，且其整体被阐述。

Claims

1.一种计算机实现的方法，包括以下步骤：

接收一部分源代码作为输入，其中所述一部分源代码以高级语言(HLL)编写；和

生成输出脚本，所述输出脚本包括选自功能受限的区块链脚本语言和/或对于功能受限的区块链脚本语言所固有的多个操作码，以使该脚本在执行时至少部分地提供所述一部分源代码中指定的功能。

2.根据权利要求1所述的方法，包括以下步骤：

提供或使用被布置为执行权利要求1中的步骤的编译器。

3.根据权利要求1或2所述的方法，其中，通过执行静态编译来生成所述输出脚本。

4.根据权利要求1、2或3所述的方法，其中：

所述区块链脚本语言受到限制，使得其不固有地支持复杂的控制流结构、递归和/或基于跳转的循环。

5.根据前述权利要求中任一项所述的方法，其中，生成所述输出脚本的步骤包括：

展开所述源代码中提供的至少一个循环结构。

6.根据前述权利要求中任一项所述的方法，还包括以下步骤：

提供或使用解释程序或虚拟机，该解释程序或虚拟机被布置为将所述输出脚本转换为能够在区块链平台上执行的形式。

7.根据前述权利要求中任一项所述的方法，还包括以下步骤：

至少一次优化所述输出脚本，以提供更高效或更精简版本的输出脚本。

8.根据前述权利要求中的任一项所述的方法，其中，生成所述输出脚本的步骤包括使用无导数优化。

9.根据前述权利要求中任一项所述的方法，其中：

被布置为执行前述权利要求中任一项所述的步骤的HLL和/或编译器组件形成软件开发工具包(SDK)的一部分。

10.根据前述权利要求中任一项所述的方法，其中：

所述源代码被布置为实施智能合约。

11.根据前述权利要求中任一项所述的方法，其中：

所述HLL包括至少一个原语或结构，其可以被直接转换成所述区块链脚本语言固有的一个或更多个原语。

12.根据前述权利要求中任一项所述的方法，其中：

所述区块链脚本语言是基于堆栈的，且所述HLL包括一个或更多个原语，所述一个或更多个原语被布置为在所述脚本语言使用的堆栈上执行操作。

13.根据前述权利要求中任一项所述的方法，其中：

所述HLL包括原语，所述原语被布置为将至所述源代码的输入的数量推入所述区块链脚本语言进行内存分配而使用的堆栈上。

14.根据前述权利要求中任一项所述的方法，其中，所述HLL包括以下原语或运算符或它们的功能等同物中的至少一个：

Initiate；

Declare；

Increment；

IF；

While；

Populate；

Monus；

Reset；

Rawscript；

Abort；

Retrieve

Hash、hash 160、或其他哈希操作或其变体。

15.一种计算机实现的方法，包括以下步骤：使用静态编译将一部分源代码转换成与区块链兼容的脚本，优选地，其中，所述静态编译包括循环展开的步骤。

16.一种计算机实现的系统，其被设置为实施前述权利要求中任一项所述的步骤。

17.根据权利要求16所述的系统，包括编译器，其被设置为：

接收一部分源代码作为输入，该源代码以高级语言(HLL)编写；和

生成输出脚本，该输出脚本包括从功能受限的区块链脚本语言中选择的多个操作码，从而使该脚本在执行时至少部分地提供所述源代码中指定的功能。

18.根据权利要求16或17所述的系统，包括软件开发工具包(SDK)。