Conflux开发使用

Conflux从0到1的过程

搭建节点

公链（以太坊）

以太坊 Ethereum 是由分散式节点所组成的网络架构，这些节点称为「以太坊节点 Ethereum Nodes」或「以太坊客户端 Ethereum Clients」。任何人只要有规格足够的电脑设备都能够加入以太坊网络中成为节点，贡献算力赚取区块挖矿奖励。

在当前的以太坊网络中，每个节点都是相互平等的，彼此间即时沟通「同步区块资料」及「打包待出块的交易（挖矿）」来维持以太坊区块链的运作。

公链一般有3种节点：全节点，轻节点，归档节点。

全节点 Full Node

全节点是拥有完整区块链帐本资料的节点，具备独立验证的能力来确认交易之有效性。具体来说全节点主要在处理下列四件事：

• 储存所有历史交易信息，资料公开透明
• 监测矿工挖出来的新区块，验证其合法性后同步该区块
• 监测区块链网络中的新交易信息，验证每个交易的合法性
• 将验证过的「交易／区块信息」广播给全网络节点

一个节点只要下载了完整且最新的区块链资料，稳定运行验证交易和同步区块信息，那它就是一个全节点了。由于每一个全节点都保有全网资料，所以即使其中部分节点出现问题，例如断网或被骇客攻击，都不会影响整个区块链网络的安全性。这即是「去中心化」记帐系统的优势所在。

同时，全节点的数量越多，也代表完整的区块链帐本被保存的份数越多，「不可篡改性」也就越强，整个区块链网络的安全性也随之提升。一但有人企图组织算力叛变，试图改变区块共识或发动双花攻击，其它正常运作的全节点可以即时验证拒绝掉这些交易。

随着持续增加的交易记录与智慧合约部署，全节点所需的储存空间也在不断增长。

矿工节点

挖矿的过程即是将验证过的待处理交易打包成新区块，并以电脑算力来计算「nonce 值」，最先找到 nonce 值成功出块并广播的矿工会获得区块奖励与所有交易之手续费（gas）作为报酬。

矿工必须要运行全节点才能即时浏览区块链历史资料进行交易验证，再将验证通过的交易进行打包。因此，所有矿工必定是全节点；然而全节点未必是矿工，运行全节点的人未必会花费电脑算力去参与新区块 nonce 值的运算来争取区块奖励。

轻节点 Light Node

轻节点顾名思义即是轻量级的节点，具体定义是不储存或维护完整的区块链副本，只储存最小量的状态来作为发送或传递交易讯息的节点。

3.1 Block Header and Body

以太坊的每个区块主要分为 Header 和 Body 两个部分存储，Body 即是交易列表；Block Header 则较为复杂，包含了前个区块的 Hash、时间戳及挖矿难度等相关参数。

在 Block Header 中采用一种名为 Merkle-Patricia Trie (MPT) 的核心资料结构来储存区块链信息，可以理解为把帐本分割成无数个小的资料块，每个资料块像是一棵树中的无数叶片，而我们把每两个相邻的叶片合并成一个字串，并算出该字串的 Hash 值。如此过程经过无数次后，最终如同所有树枝归向一个树干一般，会得到一个包含了所有区块资料的 Hash 值，称为「Merkle Root」。

3.2 轻节点信息

全节点储存了所有区块的 Block Header 与 Body（交易列表），而轻节点只储存最小量的状态：即「区块标头 Block Header」，借此大幅降低储存空间的需求。

3.3 轻节点如何验证交易

由于割舍掉区块的 Body，即所有历史的交易列表，因此当轻节点需要验证某个交易的合法性时，具体做法为：

• 向邻近的全节点发起确认请求
• 全节点收到请求后提供所需相关信息供验证

需要向全节点请求的原因是：假设有一个合约执行的交易，那么便必须要有该合约部署时的原始码（位在 Contract Created 之交易中）。由于该交易位于某个区块之 Body，故轻节点必须要向全节点请求该合约之相关信息方能进行交易验证。

3.4 轻节点的特色摘要

整体而言，轻节点大致上具备以下几点特色：

• 只储存每个区块的区块标头 Block Header
• 不一定保持随时在线（获取最新的 Block Header 信息）
• 根据需求可以只保存与自己相关的交易内容
• 无法验证大多数交易的合法性，只能验证与自己相关交易的合法性
• 无法验证新区块的正确性
• 只能检测到当前的最长链，但无法知道哪条是最长合法链

由于轻节点必须要向全节点请求与交易验证相关的 Block Body 信息，那么要怎么知道全节点回传的信息是正确的呢？

这时就要回到以太坊的资料结构来谈，前面提到轻节点为了减少储存空间，而割舍掉 Block Body，仅保留作为验证之用的 Block Header。由于存有已经验证合法之 Block Header，因此当未来需要验证相关交易时只要透过跟全节点请求相关的 Block Body 信息即可进行验证，不需要从头验证整个区块。

3.5 Block Header 与交易验证

轻节点能够利用 Block Header 验证交易的原因为： Block Header 中的 Merkle Root 即是由 Block Body 中的交易信息经由杂凑演算法（Hash Algorithm）生成的「数位指纹（Digital Fingerprint）」，因此 Block Header 可以充分代表 Block Body 内的信息。

Block Header 中的 Merkle-Patricia Trie 是一个生成 Hash 需要花费大量算力，但验证非常迅速的结构。当轻节点收到全节点提供的信息时，便能够利用已有的 Block Header 相关讯息迅速验证该信息是否正确，进一步进行交易验证。

归档节点 Archive Node

「归档节点」是在全节点的基础之上，额外储存了每个区块高度的区块状态（个人帐户与合约帐户之当时余额等信息），即针对每个区块高度当下的状态进行快照并存档。归档节点能让你快速回到某个区块高度去查询当下状态：例如你想要知道某一个帐户在区块高度 #5,000,000 的余额时便会派上用场。

归档节点的资料大小特别大，对硬体要求相当庞大。通常只有特殊的服务如「区块链浏览器：Etherscan」或「RPC Endpoint Provider：Infura」等底层服务会有架设归档节点的需求，大多数的情况全节点已非常足够。

归档节点与安全性

归档节点对于区块链的信任模型与整体安全性原则上「不会有额外的加成或影响」，全节点（包含挖矿节点）已能充分保障全网络的安全。然而如果没有人继续维护归档节点的话，查询区块链上的历史资料得花费许多的时间。Archive Node 保存了区块链上的完整历史纪录与资料，以及所有区块高度的当时全网状态。

搭建节点必要性

公链应用开发可以不搭建自己的服务器节点，使用现有的公链节点生态即可。如果需要搭建自己的服务节点，建议搭建轻节点，作为备用节点即可。搭建有自己的轻节点的好处是，当第三方服务处于断网状态时，自己的服务节点可以派上用场，不过这种概率很小很小。

合约和SDK调试阶段，公链基本都提供了侧链或测试链供使用，且大多配有IDE环境。如果想本地模拟链环境，可以本地运行一条docker链，模拟合约编译及调用环境，完成测试。

通常情况下如果想参与挖矿，运行一个全节点及挖矿程序即可，如果想作为 RPC 服务来使用则需要运行一个 ArchiveNode，轻节点则主要用于作为钱包来使用。

综上，一般不建议搭建自己的节点参与公链。其一，公链提供了性价比 较高的测试生产环境，可直接使用；其二，节点服务器会增加成本，但并未带来很高的价值。不过，如果第三方节点服务经常断线，建议搭建自己的轻节点服务做通讯，或者，如果对链的可信度低，可以搭建自己的全节点跟踪数据。

搭建节点

Conflux搭建节点参考文章：https://docs.confluxnetwork.org/crypto-notes/notes/how-to-run-conflux-node

在线IDE

推荐使用在线IDE环境，简单快捷方便。

ChainIDE地址：https://chainide.com/zh-CN/

非在线IDE，可以下载Conflux Studio。

公共钱包

Fluent是一款浏览器插件应用，作为Conflux的钱包应用。

Fluent地址：https://fluentwallet.com/

公共浏览器

区块链浏览器可以查询区块链上所有的交易数据，可以查询与自己地址相关的交易的详细数据，还可以查看自己持有的区块链资产。

树图区块链浏览器地址：https://confluxscan.net/?tab=transactions

地址生成

Conflux地址介绍

Conflux 最初使用同以太坊一样的 hex40 格式地址，但对地址首位做了限制，只有 0x0, 0x1, 0x8 三种前缀的地址是合法的，并且这三种前缀可用于区分地址的类型：

• 0x0 内置合约地址
• 0x1 普通外部账户地址
• 0x8 合约地址

但由于地址格式类似，又不能完全互相使用 (因为 Conflux 限制了固定的前缀)，导致极易与以太坊地址混用，进而导致资产丢失。为了解决此问题，Conflux 通过 CIP-37 引入了新的 Base32 格式的地址。

以太坊 hex40 地址

以太坊账户私钥是一个 256 位的字符串 (32 字节)，通常是随机生成。

18e14a7b6a307f426a94f8114701e7c8e774e7f9a47e2c2035db29a206321725

然后通过椭圆曲线算法计算得到私钥对应的 X 和 Y 值。04 + X + Y 即为公钥 (65 字节)

04
50863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352
2cd470243453a299fa9e77237716103abc11a1df38855ed6f2ee187e9c582ba6

最后对公钥 (不包含04 前缀) 进行 Keccak-256 计算得到哈希值，取最后 20 字节作为以太坊地址

1016f75c54c607f082ae6b0881fac0abeda21781

即 0x1016f75c54c607f082ae6b0881fac0abeda21781

Conflux Base32 地址

Conflux 的地址生成规则同以太坊一样，只是地址生成后强制将地址首位换成了 0x1

• 0x7defad05b632ba2cef7ea20731021657e20a7596
• 0x1defad05b632ba2cef7ea20731021657e20a7596

然后对 0x1 开头的地址进行 base32 编码，得到 Conflux 目前使用的 base32 格式地址:

cfx:aarc9abycue0hhzgyrr53m6cxedgccrmmyybjgh4xg

两种格式的地址只是编码方式不同，但所表达的信息相同，可以互相转换。转换工具：https://conflux-fans.github.io/web-toolkit/#/address-converter

不过，这种强制转换生成地址肯定是不可行的，因为根据地址，无法计算出私钥，没有私钥，链上资产都会丢失。

Base32 地址使用场景

Conflux-rust 从 v1.1.1 开始所有涉及到地址的 RPC 方法均只接受 base32 格式地址，Portal 也同步进行了升级默认显示和接受新格式的地址。主要场景均需使用新地址:

• RPC 交互
• 钱包转账
• 使用 SDK 开发应用

目前只有一种场景需要使用 hex40 checksum 格式地址，即是在开发 Solidity 智能合约时，在 Solidity 代码 中只能使用 hex40 checksum 地址（受 Solidity 编译器限制)。

另外在跟合约方法进行交互时，涉及到传参或返回结果的地方，本质也要求使用 ABI 编码的 hex40 地址。但使用 Conflux 的 SDK 进行交互时，SDK 会自动进行地址格式转换，因此可以说此种场景也是使用 base32 格式地址。

0x1 兼容地址生成

js-conflux-sdk 中的 cli 工具 cfxjs 生成

$ npx cfxjs genEthCMPTaccount
PrivateKey: 0x6c6faf9644eafe16211ad6a222f7e2a22eb3b10f3145a6226ef0b4c9ef618413
Address: 0x15d4b49ffd7a75a86901cdfce54d85548d3698dd

网页工具

网页工具，可以从助记词中快速查找一个 0x1 账号的索引和私钥。安全起见使用时请断网并打开隐私模式。

Conflux账户接口

参考：https://blog.csdn.net/wmy19890322/article/details/122580693

钱包

公链的地址一般由用户使用开源程序或官方工具生成，第三方应用服务一般不提供生成入口。

所以正常流程应该是用户使用钱包等官方平台透明地生成个人地址，然后导入到平台中进行使用，平台服务预留用户导入私钥接口即可。同时，平台需要提醒用户：不可导入非法地址，不可丢失私钥，否则链上资产将丢失。

Conflux地址详细介绍

Conflux地址详细介绍：https://docs.confluxnetwork.org/crypto-notes/notes/conflux-address

ERC1155合约

NFT遵循标准

NFT 开发者 应该 完全仔细阅读并完全遵循 EIP-721 75 或 EIP-1155 37 标准。

建议 没有同质化代币和非同质化代币混合 使用场景的应用，采用并遵循 EIP-721 75 标准。

标准合约接口和实现可以参考：

EIP-721：https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC721 152

EIP-1155：https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC1155 57

通过 uri 或 tokenURI 方法获取的 NFT 元数据 URI 地址，建议使用 placeholder 格式（image路径带参数，如：”image”: “https://s3.amazonaws.com/your-bucket/images/{id}.png”），而非每个 tokenId 存储一个 URI。

线下 NFT JSON 元数据信息 应该 遵循各个标准的 Metadata 部分，建议 不论是 721 还是 1155，都遵循 1155 的 Metadata JSON Schema 65 规范，包含 name、image、description 等字段，并在多语言支持上采用 localization 20 字段和标准（而非使用非标准的结构和字段，比如 name_en 等）。

未来 ConfluxScan 或钱包应用，可能会对没有完全遵循 EIP-721 75 或 EIP-1155 37 标准的合约，放弃支持或只提供有限的支持。

Enumerable

枚举功能可以 发现合约已经发行的和某个用户所拥有的 NFT。**如果在合约中实现，会带来额外的存储成本和 Gas 消耗**。尽管如此，为了保证 ConfluxScan 和其他具有 NFT 展示功能的钱包能够实时获取 NFT 数据，强烈建议 开发者在 CRC721 和 CRC1155 标准的合约中实现枚举功能。未来 ConfluxScan 可能会取消对 mint 事件的检索，未实现枚举功能的合约所发行的 NFT 将无法被查看。

Conflux 链上 Gas 成本较低，并且初期有代付机制，因此添加枚举功能带来的额外 Gas 和存储抵押费用是可以被完全覆盖的。

考虑到会给用户带来额外的 Gas 成本， EIP-721 中把可枚举扩展作为可选项，EIP-1155 标准直接去掉了可枚举扩展。对于 1155 合约，可以采用 Conflux 合约库中的 扩展实现。

合约

官方已提供ERC1155合约，如果无特殊需求的话，可直接使用官方的合约。

conflux-fans / conflux-contracts（基础依赖confluxfans）

OpenZeppelin / openzeppelin-contracts（基础依赖openzeppelin）

conflux-dao-toc / NFT2.0（业务层合约）

具体使用可参考chainIDE下ERC721合约示例，如下图：

另外，在区块链浏览器也能查看其他用户部署的合约源码，如下：

点击进入详情页面

构建ERC1155合约

新建空白项目

拷贝[CRC1155NatureAutoIdFixedMetadata.sol]应用合约

等待ChainIDE自动加载完依赖

编译

合约部署

部署

安装Fluent插件，注册密钥对，连接到钱包；CFX可以去测试水龙头免费领取

填写name_、symbol_，部署合约
可以理解为这个 合约 的名字和简称

验证

未经验证的合约源码不会公开，去中心化程度低一些。验证通过，源码在Scan公开，任何人都可以审查逻辑。

区块链浏览器验证合约

报错如下：


合约文件需要替换import为源内容，合并合约为单文件。合约名称为contract后的名称。

[Contract] flattener 合并 Solidity 文件的依赖到一个文件

[Contract] Remix 插件 合并依赖到一个文件（推荐，推荐，推荐，方便快速）

Remix 在线

测试

添加铸造者

铸造

转移

查所有者，公链环境没有ownerOf方法，只能查看某NFT属不属于某个人持有。

授权

区块链浏览器查看元数据

合约验证通过之后才能正常可视化显示资产，即上传源码到链上。**解析元数据需要编译的ABI文件。**

铸造时的元数据参数：

"{\"name\":\"曳戈泰尔\",\"image\":\"https://raw.githubusercontent.com/wohunlfry/picBed/master/202211161511500.png\",\"description\":\"测试\"}"

浏览器查看显示

设置代付（免费使用Conflux）

代付机制详解

绝大部分的公有链中都存在着名为 gas 的机制（或称之为 “燃气费”），该机制有着丰富的作用，如对抗拒绝服务攻击、回避智能合约的停机问题、激励矿工等。但 gas 机制也随之带来了一个问题，那就是提高了用户与智能合约进行交互的门槛 —— gas 意味着拥有区块链中的原生代币是与智能合约进行交互的 前提。

就原生代币的获取途径而言，除了挖矿外，用户只能通过链下的方式从其他用户处（也包括交易所）获取。在当前的大环境下，不管是挖矿还是链下交易，都意味着极高的门槛。此外，用户每次与合约进行交互都意味着花费 gas，每次操作都存在着成本，用户在交易之前可能权衡付出这么多 gas 是否值得。这一点在以太坊上体现得非常明显，直接在主链操作需要付出高额的 gas（不过高 gas 费的问题可以通过部分 layer2 的技术缓解）。

Conflux 中的代付机制，简而言之，就是允许其他用户为某个智能合约的交互者支付 gas 费（在 Conflux 中存储抵押费也可被代付，这里先不谈）。“被代付” 的用户发起交易时不必承担 gas 开销。代付启用后，一个余额为 0 的账户也能够与合约进行交互，极大地降低了用户与合约交互的门槛。

在 Gas 代付设置 setSponsorForGas 中除了需要设置发送的 CFX 数目（paybale 关键字所要求）与合约地址外，还需要设置参数 upperBound。该参数意味着每笔被代付交易能够消耗的 Gas 上限（单位为 Drip，即 10e-18 CFX），即该参数意味着被代付的交易需要满足 upperBound ≤ gasUsed * gasPrice。如果交易所需的 gas 超过了 upperBound, gas 费将不会被代付，而是由发起交易的用户本人进行支付。Conflux 的 tps 非常高，一般而言交易的 gasPrice 设为 1 即可满足需求。Conflux 基金会在进行代付时会将该值设置为 10G，这可以涵盖基本所有交易。

Conflux 中的代付机制详解，戳此

SponsorControl 合约

Conflux 实现了一种赞助机制来补贴用户对智能合约的使用。 因此，只要对合约调用的交易被赞助（通常由 Dapps 的运营商赞助），使用余额为零的新帐户也能够调用智能合约。 通过引入内置的 SponsorControl 合约能够记录和管理智能合约的赞助信息。

赞助 SponsorWhitelistControl 合约使用，戳此

使用

Scan合约赞助

地址：https://testnet.confluxscan.net/sponsor

赞助者是机构，赞助对象是合约

代码实现调用

略，JAVA-SDK不好实现，建议参考JS实现。

使用Scan的合约交互功能

地址：https://testnet.confluxscan.net/address/cfxtest:aaejuaaaaaaaaaaaaaaaaaaaaaaaaaaaaeprn7v0eh?tab=contract-viewer

可自由设置赞助者，设置为平台账户，可满足gas打包需求，不过无法避免DDOS攻击。

SDK开发

JAVA-SDK地址：https://github.com/conflux-chain/java-conflux-sdk，主要参考项目的README.md文件开发。

Java-Solidity - 类型映射参考：https://wiki.conflux123.xyz/books/conflux101/page/week19-1114#bkmrk-java-solidity-%E7%B1%BB%E5%9E%8B%E6%98%A0%E5%B0%84
注意Solidity下bytes在JAVA下用DynamicBytes表示，如：new DynamicBytes(“111”.getBytes())。

Test代码

package conflux.web3j;

import conflux.web3j.contract.ContractCall;
import conflux.web3j.contract.abi.DecodeUtil;
import conflux.web3j.contract.internals.AdminControl;
import conflux.web3j.contract.internals.SponsorWhitelistControl;
import conflux.web3j.response.Log;
import conflux.web3j.response.Receipt;
import conflux.web3j.types.Address;
import conflux.web3j.types.RawTransaction;
import conflux.web3j.types.SendTransactionResult;
import conflux.web3j.types.TransactionBuilder;
import org.junit.jupiter.api.Test;
import org.web3j.abi.*;
import org.web3j.abi.datatypes.*;
import org.web3j.abi.datatypes.generated.Uint256;

import java.math.BigInteger;
import java.security.*;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.spec.ECGenParameterSpec;
import java.security.spec.ECPoint;
import java.util.*;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/11/11 10:33 PM
 */
public class TestDemo {

    /**
     * 查询余额，转移代币CFX
     *
     * @throws Exception
     */
    @Test
    public void getBalance() throws Exception {

        // Use testnet RPC url create a Cfx instance, which can be used to invoke RPC method
        // Cfx cfx = Cfx.create("https://test.confluxrpc.com");
        Cfx cfx = Cfx.create("https://test.confluxrpc.com", 3, 1000);
        String ADDRESS = "cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6";
        // getBalance method can be used to query balance of one address
        BigInteger balance = cfx.getBalance(new Address(ADDRESS)).sendAndGet();
        // default unit is drip
        System.out.println("balance in Drip: " + balance);
        // Use CfxUnit.drip2Cfx convert unit to CFX
        System.out.println("balance in CFX: " + CfxUnit.drip2Cfx(balance));

        String PRIVATE_KEY = "0x2b504ded77f54b2155519870be6b6a2dbca6ace4221f0e955bfa5e401f74d557";
        // Create an account with private key
        Account account = Account.create(cfx, PRIVATE_KEY);
        // Call account.transfer method to transfer CFX to another address
        String hash = account.transfer(new Address(ADDRESS), BigInteger.valueOf(1).multiply(new BigInteger("1000000000000000000")));
        System.out.println("Transaction hash: " + hash);
    }


    /**
     * 查询nonce
     */
    @Test
    public void getBalanceWithRetry() {
        Cfx cfx = Cfx.create("https://test.confluxrpc.com", 3, 1000);
        // Invoke RPC method cfx_getEpochNumber
        BigInteger epoch = cfx.getEpochNumber().sendAndGet();
        System.out.println("Current epoch: " + epoch);

        Address addr = new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6");
        BigInteger nonce = cfx.getNonce(addr).sendAndGet();
        System.out.println(nonce);
    }

    /**
     * 地址换算
     */
    @Test
    public void calcAddress() {
        int testNetId = 1;  // mainnet is 1029
        Address a = new Address("0x13d2bA4eD43542e7c54fbB6c5fCCb9f269C1f94C", testNetId);
        Address b = new Address("cfxtest:acfhws9856kdu4xyknjmw88vcjuwte08hud79mm90g");

        System.out.println(a.getAddress()); // "cfxtest:aak7fsws4u4yf38fk870218p1h3gxut3ku00u1k1da"
        System.out.println(a.getHexAddress()); // "0x13d2bA4eD43542e7c54fbB6c5fCCb9f269C1f94C"
        System.out.println(a.getVerboseAddress()); // "NET1921:TYPE.USER:AAR8JZYBZV0FHZREAV49SYXNZUT8S0JT1AT8UHK7M3"
        System.out.println(a.getNetworkId()); // 1
        System.out.println(a.getType()); // user
    }

    /**
     * 生成以太坊地址
     */
    @Test
    public void generateAddress() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException {

        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("EC");

        ECGenParameterSpec ecSpec = new ECGenParameterSpec("secp256k1");
        keyGen.initialize(ecSpec);

        KeyPair kp = keyGen.generateKeyPair();
        PublicKey pub = kp.getPublic();
        PrivateKey pvt = kp.getPrivate();

        ECPrivateKey epvt = (ECPrivateKey) pvt;
        String sepvt = adjustTo64(epvt.getS().toString(16)).toUpperCase();
        System.out.println("s[" + sepvt.length() + "]: " + sepvt);

        ECPublicKey epub = (ECPublicKey) pub;
        ECPoint pt = epub.getW();
        String sx = adjustTo64(pt.getAffineX().toString(16)).toUpperCase();
        String sy = adjustTo64(pt.getAffineY().toString(16)).toUpperCase();
        String bcPub = "04" + sx + sy;
        System.out.println("bcPub: " + bcPub);

    }

    static private String adjustTo64(String s) {
        switch (s.length()) {
            case 62:
                return "00" + s;
            case 63:
                return "0" + s;
            case 64:
                return s;
            default:
                throw new IllegalArgumentException("not a valid key: " + s);
        }
    }


    @Test
    public void sendTransaction() throws Exception {

        Cfx cfx = Cfx.create("https://test.confluxrpc.com", 3, 1000);
        String PRIVATE_KEY = "0x2b504ded77f54b2155519870be6b6a2dbca6ace4221f0e955bfa5e401f74d557";
        // Create an account with private key
        Account account = Account.create(cfx, PRIVATE_KEY);

        Address addr = new Address("cfxtest:aak69ha8sx2mu2n9ef05arcxz7d7w50t4a9gnbnssu");

        BigInteger value = new BigInteger("1000", 16);
        TransactionBuilder txBuilder = new TransactionBuilder(addr);
        txBuilder.withChainId(1);
        txBuilder.withTo(new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6"));
        txBuilder.withValue(value);
        RawTransaction rawTx = txBuilder.build(cfx);

        // get account from accountManager, `account.send` will sign the tx and send it to blockchain
        SendTransactionResult result = account.send(rawTx);
        System.out.println(result.getTxHash());

        // or you can manually sign and send
        String hexEncodedTx = account.sign(rawTx);
        String txHash = cfx.sendRawTransaction(hexEncodedTx).sendAndGet();
        System.out.println(txHash);
    }

    @Test
    public void callMethods() throws Exception {

        // 初始化连接和合约
        Cfx cfx = Cfx.create("https://test.confluxrpc.com", 3, 1000);
        ContractCall contract = new ContractCall(cfx, new Address("cfxtest:acfhws9856kdu4xyknjmw88vcjuwte08hud79mm90g"));

        // 可游客调用方法
        // 查询账户余额
        // 单参数返回
        String amount = contract.call("balanceOf", new Address("cfxtest:aak69ha8sx2mu2n9ef05arcxz7d7w50t4a9gnbnssu").getABIAddress(), new Uint(BigInteger.valueOf(1))).sendAndGet();
        BigInteger balance = DecodeUtil.decode(amount, Uint256.class);
        System.out.println("account balance: " + balance);
        List<Type> values2 = FunctionReturnDecoder.decode(amount, Utils.convert(Arrays.asList(new TypeReference<Uint256>() {})));
        System.out.println((values2.get(0)).getValue());

        // 不可游客调用方法
        // 必须提供用户公私钥
        String PRIVATE_KEY = "0x2b504ded77f54b2155519870be6b6a2dbca6ace4221f0e955bfa5e401f74d557";
        // 调用者私钥
        // String PRIVATE_KEY = "0xbb0f7370926cbdf35ae861f4977d33716cb62faf8ceb21836b3e43881133abd4";
        // int netId = 1;
        // 合约地址
        Address contractAddress = new Address("cfxtest:acfhws9856kdu4xyknjmw88vcjuwte08hud79mm90g");
        // 调用者地址
        // 链接+私钥=调用者账户
        Account account = Account.create(cfx, PRIVATE_KEY);

        // 转移CFX
        String ADDRESS = "cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6";
        String hash = account.transfer(new Address(ADDRESS), BigInteger.valueOf(1).multiply(new BigInteger("1000000000000000000")));
        System.out.println("CFX tx hash：" + hash);

        Account.Option opt = new Account.Option();
        // opt要设置用户参数的id！！不然报错chainIdMismatch
        opt.withChainId(1);

        // 授权
        Function function3 = new Function("setApprovalForAll", Arrays.asList(new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6").getABIAddress(), new Bool(true)), Collections.emptyList());
        String data3 = FunctionEncoder.encode(function3);
        String txHash3 = account.callWithData(contractAddress, data3);
        System.out.println("setApprovalForAll tx hash: " + txHash3);

        // 查询持有NFT
        // 动态参数返回
        Function function4 = new Function("tokensOf", Arrays.asList(new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6").getABIAddress(), new Uint(BigInteger.valueOf(1)), new Uint(BigInteger.valueOf(100))), Collections.emptyList());
        String data4 = FunctionEncoder.encode(function4);
        String txHash4 = contract.call("tokensOf", new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6").getABIAddress(), new Uint(BigInteger.valueOf(1)), new Uint(BigInteger.valueOf(100))).sendAndGet();
        // 获取原始数据
        List<Type> values = FunctionReturnDecoder.decode(txHash4, Utils.convert(Arrays.asList(new TypeReference<Uint256>() {
        }, new TypeReference<DynamicArray<Uint256>>() {
        })));
        System.out.println("tokens 0 : " + (values.get(0)).getValue());
        List<Uint256> list = (List<Uint256>) values.get(1).getValue();
        for (Uint256 v : list) {
            System.out.println("tokens array : " + v.getValue());
        }

        // 查询Token元数据
        String metaDataTx = contract.call("uri", new Uint(BigInteger.valueOf(1))).sendAndGet();
        String metaData = DecodeUtil.decode(metaDataTx, Utf8String.class);
        System.out.println("元数据：" + metaData);

        // 铸造NFT
        String metaData2 = "{\"name\":\"曳戈泰尔\",\"image\":\"https://raw.githubusercontent.com/wohunlfry/picBed/master/202211161511500.png\",\"description\":\"测试\"}";
        Function function = new Function("mint", Arrays.asList(new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6").getABIAddress(), new Utf8String(metaData2), new DynamicBytes("1".getBytes())), Collections.emptyList());
        String data = FunctionEncoder.encode(function);
        String txHash = account.callWithData(contractAddress, data);
        System.out.println("mint tx hash: " + txHash);
        // 获取event数据
        // 获取token编号
        Request<Optional<Receipt>, Receipt.Response> result = cfx.getTransactionReceipt(txHash);
        Optional<Receipt> response = result.sendAndGet();
        List<Log> list1 = response.get().getLogs();
        Log log = list1.get(0);
        String valueData = log.getData();
        TypeReference uint256TypeReference = TypeReference.create(Uint256.class);
        List<TypeReference<Type>> decodeTypes = Arrays.asList(uint256TypeReference);
        List<Type> listData = DefaultFunctionReturnDecoder.decode(valueData, decodeTypes);
        System.out.println(listData.get(0).getValue());

        // 转移NFT
        // 编码方法及参数
        Function function2 = new Function("safeTransferFrom", Arrays.asList(new Address("cfxtest:aak69ha8sx2mu2n9ef05arcxz7d7w50t4a9gnbnssu").getABIAddress(), new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6").getABIAddress(), new Uint(BigInteger.valueOf(1)), new Uint(BigInteger.valueOf(1)), new DynamicBytes("1".getBytes())), Collections.emptyList());
        String data2 = FunctionEncoder.encode(function2);
        String txHash2 = account.callWithData(contractAddress, data2);
        // 返回64位开头0x8的哈希交易地址
        // 具体内容可以在 https://testnet.confluxscan.io/ 输入返回哈希搜到
        System.out.println("safeTransferFrom tx hash: " + txHash2);
    }


    @Test
    public void try_new_contract() throws Exception {
        String privateKey = "0x0e3f7f3219dd154e1b4887123ccb8472ef35341cb3c1f86d08c42b43117d776d";
        Cfx cfx = Cfx.create("https://test.confluxrpc.org/v2", 3, 1000);
        Account account = Account.create(cfx, privateKey);

        Account.Option opt = new Account.Option();
        // opt要设置用户参数的id！！不然报错chainIdMismatch
        opt.withChainId(1);

        String smart_contract_file = "xxxxxxx";

        String deploy_hash = account.deploy(opt, smart_contract_file);
        System.out.println(deploy_hash);
    }


    // 设置合约Admin
    @Test
    public void adminControl() throws Exception {

        // 初始化连接和合约
        Cfx cfx = Cfx.create("https://test.confluxrpc.com", 3, 1000);

        // 内置合约地址
        // AdminControl 合约
        Address innerContractAddress = new Address("0x0888000000000000000000000000000000000000", 1);
        ContractCall contract = new ContractCall(cfx, innerContractAddress);
        String result = contract.call("getAdmin", innerContractAddress.getABIAddress()).sendAndGet();
        System.out.println(result);

        // 必须提供用户公私钥
        String PRIVATE_KEY = "0xbb0f7370926cbdf35ae861f4977d33716cb62faf8ceb21836b3e43881133abd4";
        // 合约地址
        Address contractAddress = new Address("cfxtest:acfhws9856kdu4xyknjmw88vcjuwte08hud79mm90g");
        // 链接+私钥=调用者账户
        Account account = Account.create(cfx, PRIVATE_KEY);

        // To query builtin contract
        AdminControl ac = new AdminControl(cfx);
        org.web3j.abi.datatypes.Address contractAdmim = ac.getAdmin(contractAddress.getABIAddress());

        // To update
        Account.Option opt = new Account.Option();
        // opt要设置用户参数的id！！不然报错chainIdMismatch
        opt.withChainId(1);
        Address newAdmin = new Address("", 1);
        AdminControl ac2 = new AdminControl(account);
        String hash = ac2.setAdmin(opt, contractAddress.getABIAddress(), newAdmin.getABIAddress());
        System.out.println(hash);
    }

}

获取交易结果

有返回值的合约方法

有返回值的合约方法，直接call获取到返回值加密串，然后解密出返回值参数。

• 获取合约返回参数并解析：https://blog.csdn.net/wmy19890322/article/details/122580693
• 合约返回值hexstring 转为相应的数据类型：https://wiki.conflux123.xyz/books/conflux101/page/week19-1114

获取个人token列表及元数据

// 查询持有NFT
   // 动态参数返回
   Function function4 = new Function("tokensOf", Arrays.asList(new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6").getABIAddress(), new Uint(BigInteger.valueOf(1)), new Uint(BigInteger.valueOf(100))), Collections.emptyList());
   String data4 = FunctionEncoder.encode(function4);
   String txHash4 = contract.call("tokensOf", new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6").getABIAddress(), new Uint(BigInteger.valueOf(1)), new Uint(BigInteger.valueOf(100))).sendAndGet();
   // 获取原始数据
   List<Type> values = FunctionReturnDecoder.decode(txHash4, Utils.convert(Arrays.asList(new TypeReference<Uint256>() {
   }, new TypeReference<DynamicArray<Uint256>>() {
   })));
   System.out.println("tokens total : " + (values.get(0)).getValue());
   List<Uint256> list = (List<Uint256>) values.get(1).getValue();
   for (Uint256 v : list) {
       System.out.println("tokens array : " + v.getValue());
   }

   // 查询Token元数据
   String metaDataTx = contract.call("uri", new Uint(BigInteger.valueOf(1))).sendAndGet();
   String metaData = DecodeUtil.decode(metaDataTx, Utf8String.class);
   System.out.println("元数据：" + metaData);

无返回值的合约方法

合约的写入操作需要等待交易被打包并执行，因此无法直接获取返回结果，这时可以通过 emit Event 的方式，将数据写入到区块链中，后续可以通过获取交易 receipt 或者 cfx_getLogs|eth_getLogs 方式获取到这些 log 数据，然后通过 abi decode 解析出来。

• 获取Event的log：https://juejin.cn/post/6971741780429668365#:~:text=cfx_getTransactionReceipt
• Event编解码：https://github.com/conflux-fans/crypto-knowledge/blob/main/blogs/java-sdk-abi-encode.md#:~:text=%2C%20str)%3B-,Event%20%E7%BC%96%E8%A7%A3%E7%A0%81,-%E5%90%88%E7%BA%A6%E7%9A%84%E5%86%99

获取mint的token

// 铸造NFT
String metaData2 = "{\"name\":\"曳戈泰尔\",\"image\":\"https://raw.githubusercontent.com/wohunlfry/picBed/master/202211161511500.png\",\"description\":\"测试\"}";
Function function = new Function("mint", Arrays.asList(new Address("cfxtest:aamm7rw2cyd13a7jkea80b7zmyf7j1296e5j0tgxg6").getABIAddress(), new Utf8String(metaData2), new DynamicBytes("1".getBytes())), Collections.emptyList());
String data = FunctionEncoder.encode(function);
String txHash = account.callWithData(contractAddress, data);
System.out.println("mint tx hash: " + txHash);
// 获取event数据
// 获取token编号
Request<Optional<Receipt>, Receipt.Response> result = cfx.getTransactionReceipt(txHash);
Optional<Receipt> response = result.sendAndGet();
List<Log> list = response.get().getLogs();
Log log = list.get(0);
String valueData = log.getData();
TypeReference uint256TypeReference = TypeReference.create(Uint256.class);
List<TypeReference<Type>> decodeTypes = Arrays.asList(uint256TypeReference);
List<Type> listData = DefaultFunctionReturnDecoder.decode(valueData, decodeTypes);
System.out.println(listData.get(0).getValue());

生产环境获取CFX

购买渠道：交易所（海外交易所购买便宜） + 刺头（平台刺客可开发票，不过比较贵）

推荐购买地址：<>

可找平台刺头免费获取部署合约的CFX，部署合约之后可以申请基金会赞助，再之后可以设置平台账户作为代付账户，平台定期充值CFX。

打包用户CFX（gas）

要让用户免费使用Conflux，可以通过代付机制实现gas打包，即用户不需要持有gas也可以正常交易。

不过，为了防止恶意盗刷，需要在合约层做限制，或者在SDK业务层做限制。

防盗刷gas思路：

• 目前官方仅仅提供了白名单机制防止DDOS攻击，但这种方式无法避免白名单内账户作恶；
• gas机制和代付机制存在矛盾，目前还没有很好的解决方案，目前在代付上采取了一种“防君子不防小人” 的态度，详见：https://segmentfault.com/a/1190000041300216#:~:text=%E4%BB%98%E8%A2%AB%E6%BB%A5%E7%94%A8%E3%80%82-,%E6%81%B6%E6%84%8F%E6%B6%88%E8%80%97%E4%BB%A3%E4%BB%98,-%E5%8F%A6%E4%B8%80%E6%96%B9%E9%9D%A2%EF%BC%8C%E4%BB%A3%E4%BB%98。
• 即使在业务层也无法避免DDOS盗刷gas，因为任何用户都可以注册为白名单用户，然后进行合约调用。不过可以人为跟踪交易记录，把恶意用户从白名单移除，不过这样操作的成本很高，未必值得。

问题

1. 代付的使用场景是什么？开放0地址代付白名单，CFX会不会被恶意盗刷？
   代付的具体内容可以看https://wiki.conflux123.xyz/books/conflux101/page/sponsorwhitelistcontrol 使用场景就是一个用户没有足够的代币，项目方通过设置代付，可以直接进行调用。 往白名单中加入零地址，理论上来说，可能会被恶意盗刷，因为任何人都可以去调用合约。但是你可以在自己的合约当中进行一些限制

2. 用户去哪里购买CFX？有什么正规方便的渠道推荐？
   用户可以通过交易所。正规的渠道可以去群里找刺客进行购买

3. 假设没有恶意盗刷的情况，我可以用一个账户购买CFX，然后设置代付到部署的合约，这样其他所有的用户都不需要购买CFX，只要我这个账户定期充值CFX，保证余额充足就行。这种实操成立吗？
   成立的。需要开放白名单

4. Conflux的Core和Espace空间，建议怎么选择？

   espace是conflux的分片，可以被认为是独立的与以太坊等效的。建议怎么选择的话，得看你是否愿意是在core空间进行开发，还是在espace空间进行开发了，espace可以看成是吸引以太坊用户
   https://wiki.conflux123.xyz/books/conflux101/page/core-space-espace

5. 建议搭建自己的节点吗？如果要搭建，搭建节点的主要目的是什么呢？因为还要服务器，从成本上看不划算，感觉也没什么用。
   如果没有特别的目的的话，可以直接用官方提供的节点。搭建的目的的话，我认为可以是可以去玩POS链？因为根据该链接https://wiki.conflux123.xyz/books/conflux101/page/posregister，pos是需要注册为pos节点的，是需要有本地节点的

6. CFX可以凭空产生吗？平台想发多少就发行多少，发行到自己的账户下。还是就第一次发行之后，后面只能挖矿获得？
   CFX在创世以后，就是发行了的。后面只能通过挖矿或者锁仓获得收入来获得

7. ERC1155合约直接使用官方的可以吗？如果功能需求都满足。还是建议怎么修改一下呢？
   没有特殊需求的条件下，可以直接用官方的。如果有自己的特殊的需求，可以自己对合约进行开发，满足对应的接口就行。

8. 怎么获取合约调用的返回结果，需要通过txHash另外查询获取吗？
   合约调用的结果通过哈希来查询回执，能查询到的话就成功了。如果合约调用没有return回数据的话，可以emit一个event，再通过getlog进行查询

9. 在国内做Conflux，建议设置代付还是用户自己承担CFX呢？
   节省用户成本的情况下，可以使用代付机制。但是要尽量防止恶意用户的盗刷。

10. 如何获取铸造的token编号
    emit一个event，通过getlog获取事件数据，再解码出token编号

11. 如何确认交易的成功与失败
    通过交易hash查询交易回执，交易状态为0证明成功。
    但大多场景，能正常返回txHash就能证明成功，JAVA中可设置try-catch，没有捕捉到异常，正常拿到txhash，可默认成功。

12. Conflux环境下，正规的ERC1155合约，我可以查询任何人的资产情况，只要有合约和账户地址，而且还能查看token对应的元数据？
    通过 ConfluxScan 可以查看某一账户所拥有的 NFT 和某个合约所发行的 NFT，并且可以查看NFT的元数据。
    参考文章：https://conflux-technical-support.gitbook.io/conflux-nft-kai-fa-zhi-nan/step-1-ren-shi-confluxscan/cha-kan-nft-ji-qi-he-yue#:~:text=Powered%20By%20GitBook-,%E6%9F%A5%E7%9C%8B%20NFT%20%E5%8F%8A%E5%85%B6%E5%90%88%E7%BA%A6,-%E9%80%9A%E8%BF%87%20ConfluxScan%20%E5%8F%AF%E4%BB%A5
    根据业务需求，可自主决定合约的中心化程度。不过，公链建议实现真正的去中心化。

13. 如何查询token的持有者

TIPS：

1. 公链开发特别需要合约能力，因为整个环境都是公开的，偏公链一些的话，所有的程序都要公开，用户也能查看，所以合约不止基本的ERC1155部分，还包含了业务的后端部分，也要写进合约（函数单一职责），然后前端网页直接调用合约，完成所有操作，整个过程全透明。
   不过，后端环境也可以拆出传统后端，合约就实现基本的ERC1155功能，前端跟后端交互，不直接跟链上合约交互。但是，这种实现方式隐藏了部分程序逻辑，对用户没有全公开，没有完全意义上的去中心化，去中心化程度低一些。

2. 开发资料包：https://zhuanlan.zhihu.com/p/544986681

3. 国内使用需要备案审核

   如果面向中国大陆的用户，现在的监管环境你也理解，包括微信公众号和第三方支付公司也会有风控，需要我们的支持可能需要提供相关资料，我们进行简单的复核，复核通过才会提供相关支持，审核周期大概为3个工作日。

   需要提供的材料

   务必留下联系人联系方式，不然可能找不到联系人
   公司名称
   统一社会信用代码
   域名ICP备案信息
   ICP互联网经营许可证
   EDI经营许可证

   根据业务可能还需要：
   网络文化经营许可证
   网络出版服务许可证

   公司和产品的介绍
   公司介绍越详细越好，比如项目和产品介绍的PDF，从事的哪些业务，就如果同IP方签了IP或者其的话，最好提供一个IP相关的授权的信息。如果在微信公众号、H5或者App发售，需要微信公众号App的名字和H5的链接。

   申请企业的营业执照复印件、法人身份证复印件（均加盖公章），并留下法人联系方式

   发送至: bd@confluxnetwork.org

   通过后需要遵循以下两点
   1.涉及上海树图区块链研究院和Conflux树图区块链的宣传内容需要提前和我们同步。
   2.在Conflux树图区块链上的数字藏品，需要满足Conflux 树图区块链 “数字藏品” 合约标准和编写规范（https://forum.conflux.fun/t/conflux/15538）