devbox
煮酒与君饮
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

在TON链（The Open Network）上部署智能合约的全过程_ton智能合约开发

作者：煮酒与君饮 | 2024-06-29 17:22:14

赞

踩

ton智能合约开发

1.编写智能合约：

1.1定义变量：

在TON NETWORK（The Open Network）上部署智能合约时，定义变量是合约编写的重要步骤之一。这些变量用于存储合约中的数据和状态，并在合约执行过程中进行读取和修改。以下是一些关于在TON NETWORK上定义智能合约变量的基本概念和示例：

变量类型

TON NETWORK的智能合约通常使用Solidity或TON Virtual Machine (TVM) 特定的编程语言来编写。以下是一些常见的变量类型：

  • uint256：无符号的256位整数，用于存储数字。
  • address：地址类型，用于存储TON NETWORK上的账户地址。
  • bool：布尔类型，可以存储true或false。
  • string：字符串类型，用于存储文本数据。
  • bytes 和 bytes32：字节数组类型，用于存储任意长度的字节数据或固定长度的32字节数据。
  • 自定义类型：例如结构体（struct）和枚举（enum）等。

变量定义

在合约中定义变量时，你需要指定变量的名称和类型。以下是一个简单的示例：

  1. // SPDX-License-Identifier: MIT  
  2. pragma ton-solidity >= 0.43.0;  
  3.   
  4. contract MyContract {  
  5.     // 定义一个无符号整数变量  
  6.     uint256 public myNumber;  
  7.   
  8.     // 定义一个地址变量  
  9.     address public myAddress;  
  10.   
  11.     // 定义一个字符串变量  
  12.     string public myString;  
  13.   
  14.     // 构造函数，用于初始化变量  
  15.     constructor() public {  
  16.         myNumber = 42;  
  17.         myAddress = address.makeAddrStd(0, 0, 0); // 示例地址，实际应使用有效地址  
  18.         myString = "Hello, TON!";  
  19.     }  
  20.   
  21.     // 其他函数...  
  22. }

在上面的示例中，我们定义了三个公共变量：myNumber、myAddress和myString，并在构造函数中初始化了它们的值。这些变量是公开的（public），因此它们可以在合约外部被访问。

状态变量

在智能合约中定义的变量通常被称为状态变量，因为它们存储在合约的状态中，并随着合约的执行而更新。状态变量在合约的整个生命周期内都存在，并可以在合约的不同函数调用之间保持其值。

注意事项

  • 变量名应该是描述性的，以便其他开发者能够理解其用途。
  • 公共变量（public）将自动生成getter函数，用于在合约外部读取其值。
  • 尽量避免在合约中定义过多的状态变量，以减少合约的存储需求和复杂性。
  • 在处理敏感数据时，请确保使用适当的安全措施，如加密和访问控制。

1.2.实现合约的逻辑代码：

在TON NETWORK（The Open Network）上部署智能合约并实现合约的逻辑代码，通常涉及使用TON虚拟机（TVM）支持的编程语言，如Solidity的TON扩展版本或其他与TVM兼容的编程语言。由于TON NETWORK是基于TON虚拟机（TVM）的，智能合约的编写和部署过程与以太坊或其他基于EVM（以太坊虚拟机）的区块链平台有一些相似之处，但也有一些特定的差异。

以下是一个简化的步骤和示例，说明如何在TON NETWORK上实现智能合约的逻辑代码：

选择开发工具和环境

  • 安装TON Development Kit（TDK）或其他TON NETWORK开发工具。
  • 配置TON节点的本地或远程访问。

编写智能合约

使用Solidity的TON扩展版本或其他TVM支持的编程语言编写智能合约。以下是一个简单的Solidity示例，展示了如何在TON NETWORK上定义一个带有简单功能的智能合约：

  1. // SPDX-License-Identifier: MIT  
  2. pragma ton-solidity >= 0.43.0;  
  3.   
  4. contract MySimpleContract {  
  5.     // 定义状态变量  
  6.     uint256 public counter;  
  7.   
  8.     // 构造函数，用于初始化合约状态  
  9.     constructor() public {  
  10.         tvm.accept(); // 接受构造函数调用  
  11.         counter = 0; // 初始化计数器为0  
  12.     }  
  13.   
  14.     // 定义一个函数来增加计数器  
  15.     function incrementCounter() public {  
  16.         tvm.accept(); // 接受函数调用  
  17.         counter += 1; // 增加计数器的值  
  18.     }  
  19.   
  20.     // 定义一个函数来查询计数器的值  
  21.     function getCounter() public view returns (uint256) {  
  22.         return counter; // 返回计数器的值  
  23.     }  
  24.   
  25.     // ... 其他函数和逻辑 ...  
  26. }

编译智能合约

使用TDK中的编译器或其他TON NETWORK支持的工具将智能合约源代码编译为可在TON NETWORK上部署的二进制格式。

部署智能合约

  • 使用TON NETWORK的客户端或SDK创建一个部署交易，并将编译后的智能合约二进制文件作为交易的数据部分。
  • 签名并发送部署交易到TON NETWORK。
  • 等待交易被网络确认，并获取智能合约的地址。

调用智能合约

  • 使用TON NETWORK的客户端或SDK创建函数调用交易，并指定要调用的智能合约地址和函数参数。
  • 签名并发送函数调用交易到TON NETWORK。
  • 等待交易被网络确认，并处理返回的结果。

注意事项

  • 确保你的智能合约代码符合TON NETWORK的安全最佳实践。
  • 在部署之前，对智能合约进行充分的测试和验证。
  • 了解TON NETWORK的Gas机制和费用模型，以便正确估计和支付部署和调用智能合约的费用。
  • 注意TON NETWORK的更新和变化，因为网络规则和功能可能会随着时间的推移而发生变化。

1.3.定义合约的入口函数：

在TON NETWORK（The Open Network）上部署智能合约时，入口函数通常指的是合约的构造函数（constructor）和外部可调用函数（external functions）。构造函数用于初始化合约的状态，而外部可调用函数则是合约与其他账户或合约进行交互的接口。

构造函数（Constructor）

构造函数是智能合约的入口点之一，用于在合约被部署到TON NETWORK时初始化其状态。构造函数通常被标记为public和constructor，并且不接受任何参数（尽管在Solidity的TON扩展版本中可能有所不同）。在TON NETWORK中，构造函数通常通过tvm.accept()来接受部署交易。

示例：

  1. // SPDX-License-Identifier: MIT  
  2. pragma ton-solidity >= 0.43.0;  
  3.   
  4. contract MyContract {  
  5.     // 状态变量  
  6.     uint256 public counter;  
  7.   
  8.     // 构造函数  
  9.     constructor() public {  
  10.         tvm.accept(); // 接受部署交易  
  11.         counter = 0; // 初始化计数器  
  12.     }  
  13.   
  14.     // ... 其他函数 ...  
  15. }

外部可调用函数（External Functions）

外部可调用函数是智能合约中定义的，可以被其他账户或合约调用的函数。这些函数通常被标记为public或external，并定义了函数参数和返回值（如果有的话）。在TON NETWORK中，外部函数通常也通过tvm.accept()来接受函数调用交易。

示例：

  1. // SPDX-License-Identifier: MIT  
  2. pragma ton-solidity >= 0.43.0;  
  3.   
  4. contract MyContract {  
  5.     // 状态变量  
  6.     uint256 public counter;  
  7.   
  8.     // 构造函数  
  9.     constructor() public {  
  10.         tvm.accept();  
  11.         counter = 0;  
  12.     }  
  13.   
  14.     // 外部可调用函数：增加计数器  
  15.     function incrementCounter() public {  
  16.         tvm.accept(); // 接受函数调用  
  17.         counter += 1;  
  18.     }  
  19.   
  20.     // 外部可调用函数：获取计数器的值  
  21.     function getCounter() public view returns (uint256) {  
  22.         return counter; // 返回计数器的值  
  23.     }  
  24.   
  25.     // ... 其他函数 ...  
  26. }

在上面的示例中，incrementCounter是一个外部可调用函数，用于增加counter的值。getCounter也是一个外部可调用函数，但它被标记为view，表示它不会修改合约的状态，并且可以被其他合约或外部账户查询而无需支付任何费用。

调用智能合约的入口函数

要调用智能合约的入口函数（即构造函数或外部可调用函数），你需要使用TON NETWORK的客户端或SDK来创建一个函数调用交易，并指定要调用的合约地址、函数名以及任何必要的参数。然后，你需要签名并发送这个交易到TON NETWORK。一旦交易被网络确认，合约的函数将被执行，并且任何返回值或状态更新将被应用到合约上。

调用智能合约的入口函数

要调用智能合约的入口函数（即构造函数或外部可调用函数），你需要使用TON NETWORK的客户端或SDK来创建一个函数调用交易，并指定要调用的合约地址、函数名以及任何必要的参数。然后，你需要签名并发送这个交易到TON NETWORK。一旦交易被网络确认，合约的函数将被执行，并且任何返回值或状态更新将被应用到合约上。

请注意，具体的调用方法和步骤可能会根据你使用的TON NETWORK客户端或SDK的API和文档而有所不同。因此，在部署和调用智能合约之前，请确保你已经仔细阅读并理解了相关文档和最佳实践。

2.创建合约部署事务：

在TON NETWORK（The Open Network）上部署智能合约时，你需要创建一个合约部署事务（transaction）来将智能合约的字节码发布到网络上。这通常涉及以下几个步骤：

2.1. 编写和编译智能合约

首先，你需要使用Solidity（或TON支持的其他编程语言）编写智能合约，并使用TON编译器（如solc-js的TON扩展或TON SDK提供的工具）将源代码编译成可在TON网络上部署的字节码。

2.2.准备部署参数

在创建部署事务之前，你需要准备一些部署参数，包括：

  • 合约字节码：编译后的智能合约字节码。
  • 初始数据（如果有）：如果你的合约构造函数需要初始数据，你需要在部署事务中提供这些数据。
  • 发送者地址：用于发送部署事务的账户地址。
  • 发送者私钥：用于签名部署事务的账户私钥。
  • Gas限制和Gas价格：定义事务可以使用的最大Gas量以及每个Gas单位的价格。
  • 其他参数：根据使用的TON SDK或API的具体要求，可能还需要其他参数。

2.3. 创建和发送部署事务

使用TON SDK或API创建部署事务，并设置上述参数。然后，使用发送者私钥对事务进行签名，并通过TON网络发送该事务。

以下是一个使用TON SDK（假设存在）创建和发送部署事务的伪代码示例：

  1. # 伪代码示例，实际代码取决于TON SDK的API  
  2.   
  3. # 加载TON SDK或相关库  
  4. from ton_sdk import TonClient, ABIContract, DeploySet  
  5.   
  6. # 初始化TON客户端（连接到TON网络）  
  7. client = TonClient(...)  
  8.   
  9. # 加载合约字节码和ABI（如果有）  
  10. contract_code = ... # 从文件或字符串加载编译后的合约字节码  
  11. abi = ... # 如果可用，加载合约的ABI（Application Binary Interface）  
  12.   
  13. # 准备部署参数  
  14. deploy_params = {  
  15.     'workchain_id': 0,       # 工作链ID  
  16.     'address': None,         # 通常为None，由网络自动分配地址  
  17.     'code': contract_code,   # 合约字节码  
  18.     'data': b'',             # 初始数据（如果有）  
  19.     'pubkey': ...,           # 发送者公钥（可选，如果已设置账户）  
  20.     'grams': 1_000_000,      # 支付给合约的TON Crystal（取决于你的需求和Gas价格）  
  21.     # ... 其他可能的参数 ...  
  22. }  
  23.   
  24. # 创建部署事务  
  25. deploy_set = DeploySet.from_tvm(abi, deploy_params)  
  26.   
  27. # 发送部署事务（假设你有发送者私钥和密钥库）  
  28. response = client.processing.process_message(  
  29.     message_encode_params={  
  30.         'abi': abi,  
  31.         'address': '',        # 空字符串表示部署新合约  
  32.         'call_set': deploy_set,  
  33.         'signer': {  
  34.             'type': 'Keys',  
  35.             'keys': {  
  36.                 'public': '...',  # 发送者公钥  
  37.                 'secret': '...',  # 发送者私钥  
  38.             },  
  39.         },  
  40.         # ... 其他可能的参数 ...  
  41.     }  
  42. )  
  43.   
  44. # 处理响应并获取新合约的地址（通常在response的'out_messages'中）  
  45. # ...

注意：上述代码是伪代码，用于说明流程。实际的TON SDK API可能与此不同，因此你需要查阅TON SDK的官方文档或相关资源以获取准确的函数和参数名称。

2.4. 等待事务确认并获取合约地址

一旦你发送了部署事务，你需要等待事务被TON网络确认。这通常涉及监听事务的哈希值，直到它出现在某个区块中并被确认。一旦事务被确认，你就可以从响应中获取新合约的地址，并使用该地址与其他账户或合约进行交互。

3.签名和提交事务：

在TON NETWORK（The Open Network）上部署智能合约涉及到编写智能合约代码、编译它、构建部署事务、签名该事务，并最终将事务提交到网络上。以下是步骤的概述和可能的实现细节：

3.1. 编写和编译智能合约

首先，你需要使用TON的Solidity（或其他支持的语言）编写智能合约，并使用TON编译器（如solc-js的TON扩展或TON SDK提供的工具）将源代码编译成可在TON网络上部署的字节码。

3.2. 准备部署事务

在部署之前，你需要准备部署事务的数据，这通常包括：

  • 工作链ID：指定在哪个工作链上部署合约。
  • 初始数据（如果有）：如果你的合约构造函数需要初始数据，你需要在这里提供。
  • 合约字节码：编译后的智能合约字节码。
  • Gas限制和Gas价格：定义事务可以使用的最大Gas量以及每个Gas单位的价格。
  • 其他参数：如公钥、地址等，取决于TON SDK或API的具体要求。

3.3. 签名部署事务

在将部署事务发送到TON网络之前，你需要使用你的私钥对事务进行签名。这通常是通过TON SDK或API的某个函数完成的，该函数会接受事务数据、私钥和其他相关参数，并返回签名后的事务。

3.4. 提交签名后的事务

一旦事务被签名，你就可以通过TON SDK或API的某个函数将其提交到网络上。这个函数会接受签名后的事务数据，并将其发送到TON网络的节点进行验证和执行。

以下是一个使用TON SDK（假设存在）签名和提交部署事务的伪代码示例：

  1. # 伪代码示例，实际代码取决于TON SDK的API  
  2.   
  3. # 初始化TON客户端  
  4. client = TonClient(...)  
  5.   
  6. # 加载合约字节码（假设你已经有了一个编译后的字节码）  
  7. contract_code = ...  
  8.   
  9. # 准备部署参数（这取决于你的智能合约和TON SDK的具体要求）  
  10. deploy_params = {  
  11.     'workchain_id': 0,       # 工作链ID  
  12.     'code': contract_code,   # 合约字节码  
  13.     # 可能还需要其他参数，如初始数据、Gas限制等  
  14. }  
  15.   
  16. # 假设你有一个函数可以构建部署事务（这取决于TON SDK的具体实现）  
  17. deploy_message = build_deploy_message(deploy_params)  
  18.   
  19. # 使用你的私钥对事务进行签名（这取决于你的密钥管理方式和TON SDK的实现）  
  20. signed_deploy_message = sign_message(deploy_message, private_key)  
  21.   
  22. # 提交签名后的事务到TON网络  
  23. response = client.processing.process_message(signed_deploy_message)  
  24.   
  25. # 处理响应并获取新合约的地址（通常在response的某个部分中）  
  26. # ...

注意：上述代码是伪代码，用于说明流程。实际的TON SDK API可能与此不同，因此你需要查阅TON SDK的官方文档或相关资源以获取准确的函数和参数名称。此外，密钥管理和签名过程也可能因你的应用程序的架构和安全性要求而有所不同。

3.5. 等待事务确认并获取合约地址

一旦你提交了事务，你需要等待事务被TON网络确认。这通常涉及监听事务的哈希值，直到它出现在某个区块中并被确认。一旦事务被确认，你就可以从响应中获取新合约的地址，并使用该地址与其他账户或合约进行交互。

4.确认合约部署：

在TON NETWORK（The Open Network）上确认合约部署通常涉及以下几个步骤：

4.1. 监听事务哈希

当你通过TON SDK或API发送部署事务后，你会收到一个事务哈希（transaction hash），这个哈希是事务的唯一标识符。你需要监听这个哈希以获取事务的状态和结果。

4.2. 等待事务被写入区块

一旦事务被发送到网络，它将被节点接收并尝试包含在一个新的区块中。这个过程可能需要一些时间，具体时间取决于网络状况和节点负载。你可以使用TON SDK或API提供的函数来轮询事务的状态，直到它被写入一个区块并被确认。

4.3. 检查事务状态

当事务被写入区块并被确认后，你可以查询该事务的状态以确认合约是否成功部署。事务状态通常包括成功（committed）或失败（rejected）等选项。如果事务成功，你通常还可以获取新合约的地址和其他相关信息。

4.4. 获取合约地址

如果事务成功，你将能够从响应中获取新合约的地址。这个地址是你在TON网络上与合约进行交互的唯一标识符。确保妥善保存这个地址，以便将来使用。

伪代码示例,以下是一个使用TON SDK（假设存在）确认合约部署的伪代码示例：

  1. # 伪代码示例，实际代码取决于TON SDK的API  
  2.   
  3. # 假设你已经有了一个事务哈希（transaction_hash）  
  4. transaction_hash = ...  
  5.   
  6. # 初始化TON客户端  
  7. client = TonClient(...)  
  8.   
  9. # 轮询事务状态直到它被确认  
  10. while True:  
  11.     # 使用TON SDK或API查询事务状态  
  12.     transaction_status = client.net.query_collection(  
  13.         collection='transactions',  
  14.         filter={  
  15.             'id': {'eq': transaction_hash},  
  16.             'status': {'neq': 'unfinalized'}  # 假设'unfinalized'表示事务尚未被确认  
  17.         },  
  18.         result='id, status, addr'  # 请求返回事务ID、状态和地址  
  19.     )  
  20.   
  21.     # 检查事务状态  
  22.     if transaction_status and transaction_status[0]['status'] == 'committed':  
  23.         # 事务已成功被写入区块  
  24.         contract_address = transaction_status[0]['addr']  # 假设'addr'字段包含合约地址  
  25.         print(f"合约已成功部署，地址为：{contract_address}")  
  26.         break  
  27.     else:  
  28.         # 事务尚未被确认，稍后再试  
  29.         time.sleep(5)  # 等待一段时间后再查询  
  30.   
  31. # 现在你可以使用contract_address与合约进行交互了

注意：上述代码是伪代码，用于说明流程。实际的TON SDK API可能与此不同，因此你需要查阅TON SDK的官方文档或相关资源以获取准确的函数和参数名称。此外，查询事务状态的方式和返回的数据结构也可能因TON SDK的版本和配置而有所不同。

实际部署时的注意事项

  • 确保网络环境：在部署之前，确保你连接到了正确的TON网络环境（主网、测试网等）。
  • 检查Gas费用和限制：设置合理的Gas费用和限制以确保事务能够被及时确认和执行。
  • 处理错误和异常：在编写代码时，确保能够妥善处理可能出现的错误和异常，如网络故障、事务失败等。
  • 验证合约功能：一旦合约被部署，你应该通过调用合约的函数来验证其功能是否符合预期。

5.测试与验证：

在TON NETWORK（The Open Network）上测试与验证已部署的合约是确保合约功能正常且符合预期的重要步骤。以下是在TON NETWORK上测试与验证已部署合约的推荐步骤：

5.1. 连接到TON网络

首先，你需要一个TON网络的客户端或SDK，并连接到测试网络（通常建议先在测试网络上验证合约，然后再迁移到主网）。

5.2. 获取合约地址

确保你已经有了要测试的合约的地址。这通常是在合约部署过程中由TON网络返回的。

5.3. 编写测试用例

根据你的合约功能，编写一系列测试用例。这些用例应该覆盖合约的所有关键功能和边界条件。

5.4. 调用合约函数

使用TON SDK或客户端，构造消息（包括函数参数、Gas限制和Gas价格等），并签名该消息以调用合约的函数。

5.5. 验证返回值

检查合约函数的返回值是否与预期相符。你可能需要解析从网络返回的原始数据以获取有用的信息。

5.6. 检查状态更改

如果合约更改了任何状态（例如，更新了某个变量的值或创建了一个新的合约），请确保这些更改已按预期发生。

5.7. 错误处理和异常捕获

在测试过程中，确保能够妥善处理可能出现的错误和异常。这可能包括网络错误、合约执行错误等。

5.8. 性能分析

如果可能的话，分析合约的执行时间和Gas消耗。这有助于你了解合约的性能瓶颈，并可能需要进行优化。

5.9. 迭代和重复测试

根据测试结果和反馈，对合约进行必要的修改，并重复测试过程以确保所有问题都已解决。

5.10. 迁移到主网

一旦在测试网络上验证了合约的功能和性能，你可以考虑将其迁移到主网。但请注意，主网上的操作可能会产生实际费用，并且可能具有更高的风险。

5.11.示例（伪代码）

以下是一个使用TON SDK（假设存在）测试已部署合约的伪代码示例：

  1. # 伪代码示例，实际代码取决于TON SDK的API  
  2.   
  3. # 初始化TON客户端并连接到测试网络  
  4. client = TonClient(...)  
  5.   
  6. # 假设你已经有了合约地址和要调用的函数名以及参数  
  7. contract_address = '...'  
  8. function_name = '...'  
  9. function_params = {...}  
  10.   
  11. # 构造并签名调用合约函数的消息  
  12. call_message = build_call_message(contract_address, function_name, function_params, ...)  
  13. signed_call_message = sign_message(call_message, private_key)  
  14.   
  15. # 发送并等待消息处理结果  
  16. result = client.processing.process_message(signed_call_message)  
  17.   
  18. # 解析并验证结果  
  19. # 注意：这里的解析和验证逻辑取决于你的合约功能和返回的数据结构  
  20. # 示例：  
  21. if 'out_messages' in result and 'body' in result['out_messages'][0]:  
  22.     # 解析并检查返回值  
  23.     return_value = parse_return_value(result['out_messages'][0]['body'])  
  24.     assert return_value == expected_value, "Returned value does not match expected value"  
  25. else:  
  26.     print("Failed to receive expected output from the contract")

注意事项

  • 安全性：在测试过程中，请确保你的私钥和敏感信息不会被泄露。
  • 日志记录：记录所有的测试步骤、输入和输出，以便在出现问题时能够轻松地回溯和调试。
  • 持续集成/持续部署（CI/CD）：如果可能的话，将测试过程集成到你的CI/CD管道中，以确保每次代码更改都会自动进行测试。

请注意，上述步骤可能会根据你的具体需求和TON NETWORK的版本而略有不同。在实际操作过程中，建议参考TON NETWORK的官方文档或教程以获取更详细和准确的信息。

6.声明与分享

技术分享：本文所提供的技术内容旨在分享与交流，旨在促进技术学习与进步。

非投资建议：本文所述技术内容并不构成任何投资建议，读者在使用相关技术时，应基于自身判断与风险评估，独立决策。

责任声明：若读者在未经授权或违反法律法规的情况下使用本文提供的代码或技术，其产生的一切后果将由读者自行承担，与本文作者无关。

欢迎指正：若您在阅读过程中发现任何错误或不足之处，欢迎通过留言的方式提出宝贵意见与建议，我们将不胜感激。

联系方式：WX: LALAKO_2，如有任何疑问或需要进一步交流，欢迎随时联系。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/769830
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号