长安链搭建及开发使用

根据官方文档搭建一条单机的4节点区块链，部署区块链浏览器，部署ERC1155合约，编写SDK调用。

本文档于2022-10-22形成，文中涉及的一些官方bug（可能）只针对当前时间的当前版本，后续版本是否存在，得各自甄别。

长安链从0到1的过程

硬件选型

4核8G2Mb200G数据盘（数据盘需要另外挂载）的ECS服务器，操作系统选择CentOS7.6。

软件依赖

（前置条件）
软件依赖目录：https://docs.chainmaker.org.cn/tutorial/%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8.html#id7

git，golang>1.16+，docker>18+，docker-compose，gcc>4+，glibc>2.18，tmux，wasmer 运行时库 libwasmer_runtime_c_api.so。

安装长安链管理台

通过长安链管理台安装长安链。
参考文章链接：https://docs.chainmaker.org.cn/dev/%E7%AE%A1%E7%90%86%E5%B9%B3%E5%8F%B0.html#id9；
参考视频链接：https://www.bilibili.com/video/BV1MU4y197KW/?spm_id_from=pageDriver

建议修改配置文件让出80端口给区块链浏览器使用，到配置文件修改端口，注意docker映射端口和连接应用端口

设置管理平台访问端口为90
长安链管理平台访问地址：http://localhost:90

删除容器及数据卷（重新开始）

1
docker-compose down -v

Tips：链重启后，管理台需要重新订阅才生效

安装长安链

设置长安链在内网运行，节点node的IP都设置为内网IP。

长安链运行ERROR（可不管）
cmlogagentd文件缺失解决方案：https://git.chainmaker.org.cn/chainmaker/issue/-/issues/36

如果客户端调用SDK连接长安链失败，建议关闭所有的TLS
关闭TLS后，长安链数据明文传输，但是都在内网系统，可保证数据传输安全性

安装区块链浏览器

参考文章：https://docs.chainmaker.org.cn/operation/%E5%8C%BA%E5%9D%97%E9%93%BE%E6%B5%8F%E8%A7%88%E5%99%A8.html#id2

注意：可不用调整配置文件，docker-compose直接启动
但是，建议设置区块链浏览器端口为80，方便后期对外开放，到配置文件修改端口，注意docker映射端口和连接应用端口

建议修改MySQL对外端口为3307，避免与管理平台相同，外部访问困难

设置区块链浏览器访问端口为80
访问地址：http://localhost:80

删除容器及数据卷（重新开始）

1
docker-compose down -v

Tips：链重启后，需要修改订阅（一样配置即可）才生效

合约solidity编译

合约开发语言与虚拟机关系：https://docs.chainmaker.org.cn/dev/%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6.html

部署solidity合约需要选择EVM虚拟机，并上传 .bin 和 .abi 两个合约文件。参考：https://cloud.tencent.com/document/product/663/72542

FISCO编译

针对FISCO合约迁移长安链，可到WeBase控制台-合约管理-合约IDE-目标合约，直接复制abi和bin内容。
或者
右上角的导出java项目，也能得到两合约文件。（推荐）

ChainMaker-docker编译

ChainMaker的 Docker 镜像编译 solidity 合约代码：
solc 编译命令使用的是 0.8.4+**commit.c7e474f2.Linux.g++ 版本的编译器，被编译的 solidity 合约版本号必须大于等于 0.8.4，否则有可能编译告警或报错。
如果开发者不愿意修改 solidity 合约以适应 solc 编译器的版本，那么也可以直接使用 **Remix 编译。通过 Remix 编译出的字节码也可以在长安链上直接部署运行。

MacOS安装docker：https://yeasy.gitbook.io/docker_practice/install/mac
Docker Desktop for Apple silicon：https://docs.docker.com/desktop/mac/apple-silicon/

使用官方编译器，升级合约版本从0.5到0.8

Remix编译

在线Remix地址：https://remix.ethereum.org
Remix编译合约教程：https://junyiseo.com/solidity/1020.html
Remix获取abi和bin文件：https://www.cnblogs.com/YpfBolg/p/14772356.html

Tips

合约初始化部署失败：合约编译不正确

附

长安链官方go语言ERC合约：https://git.chainmaker.org.cn/contracts/contracts-go/-/tree/master

部署调用合约

长安链管理台

通过长安链管理平台部署的合约，合约创建者为当前登录用户。针对简单合约，可以通过控制台成功调用。但是针对只能创建者调用的复杂合约，管理台部署的合约则不能调用成功。因为管理台部署合约的用户是当前登录用户，而调用合约的用户却是用户证书中的用户，二者不一致，所以调用一定不成功。针对这种复杂合约，只能通过CMC工具或者客户端SDK部署。还有用户一定要添加到链上才可以调用合约，在pwc和pwk模式下。

通过管理台调用合约参考：https://docs.chainmaker.org.cn/v2.3.0_alpha/html/instructions/%E9%83%A8%E7%BD%B2%E7%A4%BA%E4%BE%8B%E5%90%88%E7%BA%A6.html

管理台调用合约交易失败解决方案：合约内部限制，需通过CMC工具或SDK部署及调用，以满足内部限制。

Tips：不建议使用长安链管理台部署合约，除非很简单的合约。感觉使用管理台部署合约，合约在使用中会出现些许意想不到的bug，徒增工作量。

客户端SDK

注意查看长安链版本号，需保证SDK版本与长安链版本适配。

SDK源码仓库：https://git.chainmaker.org.cn/chainmaker/sdk-java/-/tree/v2.1.0
SDK源码在实际项目中被打包为依赖引入工程使用。
SDK的Test部分描述了常用的调用方式，在工程开发中，有很强的参考性。

长安链客户端参考demo：https://git.chainmaker.org.cn/chainmaker/sdk-java-demo/-/tree/v2.2.0
需要修改的配置：sdk_config.yml，InitClient，把节点node的certs文件夹下载到工程目录crypto-config下
合约调用部分参考SDK的Test修改

sdk_config.yml

1
2
3
# 如果没有开启TLS，enable_tls修改为false
enable_tls: false
tls_host_name: "chainmaker.org"

针对ERC1155合约转移调用失败，铸造查询等调用成功，解决：目标地址必须是链上用户才能转移成功，且要是私钥模式的长安链，证书模式的估计不行。私钥模式下，得先将私钥加入到链上，然后才能转移成功。

外部私钥用户授权平台地址方法（NFT持有者充当调用者，而不是平台管理员充当调用者）：见PWK模式长安链

修改链账户模式

修改长安链账户模式为PWK模式（原来为cert模式）

ERC1155需要在PWK模式下才能正常运行，基于私钥+公钥+地址的合约需要使用PWK模式部署。

模式对比

对比项 \ 身份模式 PermissionWithCert PermissionWithKey Public
模式名称 证书模式 公钥注册模式 公钥模式
模式简称 cert 模式 pwk 模式 pk 模式
账户类型 节点账户 (共识节点、同步节点、轻节点), 用户账户 (管理员、普通用户) 同证书模式 同证书模式
账户标识 数字证书 公钥 / 地址 公钥 / 地址
是否需要准入 是，证书需要 CA 签发 是，账户需要管理员在链上注册 否，普通用户可直接调用合约
账户与组织关系 账户属于某个组织 账户属于某个组织 账户无组织概念
适用链类型 联盟链 联盟链 公链
共识算法 TBFT、RAFT、MaxBFT TBFT、RAFT TBFT、DPOS

长安链管理平台目前只支持证书模式链，所以部署PWK模式的长安链只能通过命令工具部署，不能通过长安链可视化部署。
长安链区块链浏览器目前也只支持证书模式链

安装版本：v2.2.1，这个版本相对来说比较完善。

更高版本[v2.3.0_alpha]存在严重bug：SDK计算的地址和链上地址不一致【公私钥计算（SDK）出来的地址和链上地址不一样，即使是官方cmc工具生成的密钥对也是一样的，直接废掉。猜测是SDK的计算方法与链上的计算方法不一致导致的，等官方后续版本改进。】

命令工具部署长安链

一定修改 chainmaker-cryptogen/config/pwk_config_template.yml 中的 pk_algo 为RSA2048，ecc_p256下客户端实现非常非常困难。

长安链PWK模式下，要启用长安链管理平台和长安链区块链浏览器，需要改写源码实现

密钥对生成

长安链用户地址说明：https://docs.chainmaker.org.cn/instructions/%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%E5%BC%80%E5%8F%91.html

通过RSA2048工具生成对应公私钥对，以字符串形式存储数据库。
如果没有修改pk_algo为RSA2048，默认为ecc_p256，则需要生成ecc_p256的密钥对（生成困难）。
建议修改pk_algo，生成常见的RSA2048密钥对。

验证密钥对合法性

如果密钥对类型不对，通过官方SDK计算出来的地址和链上的实际地址不一定相同，最好验证一下。

在ERC1155环境下（前提：密钥对添加到链上用户），可以使用当前用户作为调用者，调用ERC1155的create方法，再通过creators方法便可查询到当前token的铸造者地址，即当前用户的链上地址。再通过官方SDK方法，输入公钥，计算出地址。比较二者是否相同。

如果不相同的话，需看一下官方文档，看官方支持的密钥对算法，生成官方支持的公私钥对才行。

密钥对添加到链上用户

密钥对生成之后，需要使用公钥，把用户添加到链上，建议选择client角色。作为链上用户，可以以私钥发起链上调用，如完成ERC1155的授权方法、转移方法等。

ecc_p256难题

第一次搭建长安链，全部使用默认参数，即pk_algo为ecc_p256，遇到问题：

  • JAVA客户端通过SDK一直连接不上链，一直报错，但是python-sdk和go-sdk能正常使用。大概原因是java-sdk当前版本还不支持这种算法。修改pk_algo为RSA2048，JAVA环境下才能正常连接。

python-sdk实现（PWK）

配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
chain_client:
  # 链ID
  chain_id: "chain1"
  # 组织ID
  org_id: "wx-org1.chainmaker.org"

  # 客户端用户交易签名私钥路径
  user_sign_key_file_path: "./crypto-config/wx-org1.chainmaker.org/admin/admin.key"
  # 签名使用的哈希算法，和节点保持一直
  crypto:
    hash: SHA256
  auth_type: permissionedWithKey
  # 默认支持TimestampKey，如果开启enableNormalKey则使用NormalKey
  enable_normal_key: false

  nodes:
    - # 节点地址，格式为：IP:端口:连接数
      node_addr: "59.110.154.31:12301"
      # 节点连接数
      conn_cnt: 10
    - # 节点地址，格式为：IP:端口:连接数
      node_addr: "59.110.154.31:12302"
      # 节点连接数
      conn_cnt: 10
    - # 节点地址，格式为：IP:端口:连接数
      node_addr: "59.110.154.31:12303"
      # 节点连接数
      conn_cnt: 10
    - # 节点地址，格式为：IP:端口:连接数
      node_addr: "59.110.154.31:12304"
      # 节点连接数
      conn_cnt: 10

  archive:
    # 数据归档链外存储相关配置
    type: "mysql"
    dest: "root:123456:localhost:3306"
    secret_key: xxx

  rpc_client:
    # grpc客户端最大接受容量(MB)
    max_receive_message_size: 16

配置文件创建client

1
2
3
4
5
6
7
8
9
def pwk_with_rsa(config_dir):
    sdk_config_file = os.path.join(config_dir, 'sdk_config_pwk.yml')
    os.chdir(config_dir)
    cc = ChainClient.from_conf(sdk_config_file)
    return cc

# 建立连接
sdk_config_path = '/Users/chenlianghong/Documents/NFT/ChainMaker/code/sdk-python-v2.2.0/tests/resources'
cc = pwk_with_rsa(sdk_config_path)

持有者充当调用者

1
2
3
4
5
6
7
8
9
10
11
12
13
user = User(org_id='wx-org1.chainmaker.org',
						auth_type=AuthType.PermissionedWithKey,
            hash_type=HashType.SHA256,
            sign_key_bytes=file_utils.read_file_bytes(
                '/Users/chenlianghong/Documents/NFT/ChainMaker/code/sdk-python-v2.2.0/tests/resources/testpvk.key')
            # sign_key_bytes=str.encode(private_key_str)
            )
node = Node(
    node_addr='59.110.154.31:12301',
    conn_cnt=5,
    trust_cas=[]
)
cc = ChainClient(chain_id='chain1', user=user, nodes=[node])

部署合约

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
crypto_config_path = '/Users/chenlianghong/Documents/NFT/ChainMaker/code/sdk-python-v2.2.0/tests/resources/crypto-config'
endorsers_config = [{'org_id': 'wx-org1.chainmaker.org',
                     'user_sign_key_file_path': f'{crypto_config_path}/wx-org1.chainmaker.org/admin/admin.key',
                     'auth_type': 'permissionedWithKey'
                     },
                    {'org_id': 'wx-org2.chainmaker.org',
                     'user_sign_key_file_path': f'{crypto_config_path}/wx-org2.chainmaker.org/admin/admin.key',
                     'auth_type': 'permissionedWithKey'},
                    {'org_id': 'wx-org3.chainmaker.org',
                     'user_sign_key_file_path': f'{crypto_config_path}/wx-org3.chainmaker.org/admin/admin.key',
                     'auth_type': 'permissionedWithKey'},
                    {'org_id': 'wx-org4.chainmaker.org',
                     'user_sign_key_file_path': f'{crypto_config_path}/wx-org4.chainmaker.org/admin/admin.key',
                     'auth_type': 'permissionedWithKey'}
                    ]

def create_contract(contract_name: str, version: str, byte_code_path: str, runtime_type: RuntimeType, params: dict = None, with_sync_result=True) -> dict:
    """创建合约"""
    # 创建请求payload
    payload = cc.create_contract_create_payload(contract_name, version, byte_code_path, runtime_type, params)
    # 创建背书
    # 背书用户是组织下的admin用户，路径/wx-orgx.chainmaker.org/admin/admin.key
    endorsers = cc.create_endorsers(payload, endorsers_config)
    # 携带背书发送请求
    res = cc.send_request_with_sync_result(payload, with_sync_result=with_sync_result, endorsers=endorsers)
    # 交易响应结构体转为字典格式
    return json_format.MessageToDict(res)

solidity_bin = '/Users/chenlianghong/Documents/NFT/ChainMaker/code/sdk-python-v2.2.0/tests/resources/ERC1155MixedFungibleMintable.bin'
contract_name = calc_evm_contract_name('ERC1155')
result = create_contract(contract_name, '1.0', solidity_bin, RuntimeType.EVM)
print(result)

添加/查询/删除外部公钥用户

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 添加外部公钥用户
org_id = 'wx-org1.chainmaker.org'
role = 'client'
pubkey_file_path = os.path.join('/Users/chenlianghong/Documents/NFT/ChainMaker/code/sdk-python-v2.2.0/tests/resources/crypto-config/wx-org1.chainmaker.org/user/client1/client1.pem')
pubkey = open(pubkey_file_path).read()
# pubkey = '04e64eee3589176526ae062bbc82be767988a2f1d34b6bd481282aa7fc99e6d93509d265db0c29d51ce322cab2802a5bcc787a79cc993aae13259b9947673f4ef4'
payload = cc.create_pubkey_add_payload(pubkey, org_id, role)
# endorse_users = [User.from_conf(**item) for item in endorsers_config]
# res = cc.send_manage_request(payload, endorse_users=endorse_users)
endorsers = cc.create_endorsers(payload, endorsers_config)
res = cc.send_pubkey_manage_request(payload, endorsers=endorsers)
print(res)

# 查询外部公钥用户
# pubkey = '04e64eee3589176526ae062bbc82be767988a2f1d34b6bd481282aa7fc99e6d93509d265db0c29d51ce322cab2802a5bcc787a79cc993aae13259b9947673f4ef4'
pubkey_file_path = os.path.join('/Users/chenlianghong/Documents/NFT/ChainMaker/code/sdk-python-v2.2.0/tests/resources/crypto-config/wx-org1.chainmaker.org/user/client1/client1.pem')
pubkey = open(pubkey_file_path).read()
payload = cc.create_pubkey_query_payload(pubkey)
res = cc.send_request_with_sync_result(payload)
assert hasattr(res, 'contract_result'), '公钥不存在'
print(MessageToDict(res))

# 删除公钥用户
# pubkey = '04e64eee3589176526ae062bbc82be767988a2f1d34b6bd481282aa7fc99e6d93509d265db0c29d51ce322cab2802a5bcc787a79cc993aae13259b9947673f4ef4'
pubkey_file_path = os.path.join('/Users/chenlianghong/Documents/NFT/ChainMaker/code/sdk-python-v2.2.0/tests/resources/crypto-config/wx-org1.chainmaker.org/user/client1/client1.pem')
pubkey = open(pubkey_file_path).read()
org_id = 'wx-org1.chainmaker.org'
payload = cc.create_pubkey_delete_payload(pubkey, org_id)
endorse_users = [User.from_conf(**item) for item in endorsers_config]
res = cc.send_manage_request(payload, endorse_users=endorse_users)
print(res)

调用合约

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def invoke_contract_evm(cc, method_temp, params_temp):
    # 调用EVM合约
    contract_name = 'ERC1155'
    method = method_temp
    params = params_temp
    contract_name = calc_evm_contract_name(contract_name)
    method, params = calc_evm_method_params(method, params)

    res = cc.invoke_contract(contract_name, method, params, with_sync_result=True)
    assert res.code == 0, res.contract_result.result

# 转移nft
method = 'safeTransferFrom'
params = [{"address": "0x106c623427ebc87be2ede9793812d6f2cb690d89"},
          {"address": "0x2f4f0c857a8a2d8bf10bf8d588102c1647803239"},
          {"uint256": "57896044618658097711785492504343953926975274699741220483192166611388333031430"},
          {"uint256": "1"},
          {"bytes": "1".encode()}]
invoke_contract_evm(cc, method, params)

获取mint铸造的token列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def invoke_contract_evm(cc, method_temp, params_temp):
    # 调用EVM合约
    contract_name = 'ERC1155'
    # method = 'updateBalance'
    # params = [{"uint256": "10000"}, {"address": "0xa166c92f4c8118905ad984919dc683a7bdb295c1"}]
    method = method_temp
    params = params_temp
    contract_name = calc_evm_contract_name(contract_name)
    method, params = calc_evm_method_params(method, params)

    res = cc.invoke_contract(contract_name, method, params, with_sync_result=True)
    return res


# 铸造NFT
method = 'mintNonFungible'
params = [{"uint256": "57896044618658097711785492504343953927655839433583097410118915826251869454336"},
          {"address[]": ["0x402409dba5ea71116b37bcbd354a6711d0e0e443","0x402409dba5ea71116b37bcbd354a6711d0e0e443"]}]
res = invoke_contract_evm(cc, method, params)
print(msg_to_dict(res))


# 获取token列表
token_list = []
for i in range(len(msg_to_dict(res)['contractResult']['contractEvent'])):

    token = int("0x" + msg_to_dict(res)['contractResult']['contractEvent'][i]['eventData'][3][:64], 16)

    token_list.append(token)

根据公私钥计算地址

1
2
3
4
5
6
7
8
9
10
11
12
# 根据公钥获取用户地址
pwk_path = '/Users/chenlianghong/Documents/NFT/ChainMaker/code/sdk-python-v2.2.0/tests/resources/testpuk.pem'
pwk = load_public_key_file(pwk_path)
address = get_evm_address_from_public_key(pwk)
print("公钥计算地址：" + address)

# 根据私钥获取用户地址
pvk_path = '/Users/chenlianghong/Documents/NFT/ChainMaker/code/sdk-python-v2.2.0/tests/resources/testpvk.key'
private_key, _ = load_key_file(pvk_path)
pwk = private_key.public_key()
address = get_evm_address_from_public_key(pwk)
print("私钥计算地址：" + address)

java-sdk实现（PWK）

部署的ERC1155合约的safeTransferFrom一直调用不成功，使用官方SDK编码encode的（其他方法正常调用）。
和python-SDK对比发现，二者encode后的method完全不一样，但都是使用官方SDK编码的。

java下方法safeTransferFrom编码后method：34e190b2
python下方法safeTransferFrom编码后method：f242432a

不得已放弃JAVA实现长安链客户端，选择使用python的Django实现。（望后续版本迭代中修复这个bug）

部分SDK使用如下，仅供参考。

sdk_config_pwk.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
chain_client:
  # 链ID
  chain_id: "chain1"
  # 组织ID
  org_id: "wx-org1.chainmaker.org"

  # 客户端用户交易签名私钥路径（相对路径或绝对路径）
  user_sign_key_file_path: "src/main/resources/crypto-config/wx-org1.chainmaker.org/admin/admin.key"
  # 签名使用的哈希算法，和节点保持一直
  crypto:
    hash: SHA256
  auth_type: permissionedWithKey

  nodes:
    - # 节点地址，格式为：IP:端口:连接数
      node_addr: "59.110.154.31:12301"
      # 节点连接数
      conn_cnt: 10
    - # 节点地址，格式为：IP:端口:连接数
      node_addr: "59.110.154.31:12302"
      # 节点连接数
      conn_cnt: 10
    - # 节点地址，格式为：IP:端口:连接数
      node_addr: "59.110.154.31:12303"
      # 节点连接数
      conn_cnt: 10
    - # 节点地址，格式为：IP:端口:连接数
      node_addr: "59.110.154.31:12304"
      # 节点连接数
      conn_cnt: 10

  archive:
    # 数据归档链外存储相关配置
    type: "mysql"
    dest: "root:123456:localhost:3306"
    secret_key: xxx

  rpc_client:
    # grpc客户端最大接受容量(MB)
    max_receive_message_size: 16

InitClient

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
package chainmaker.sdk.demo;

import org.chainmaker.sdk.ChainClient;
import org.chainmaker.sdk.ChainManager;
import org.chainmaker.sdk.SdkException;
import org.chainmaker.sdk.User;
import org.chainmaker.sdk.config.*;
import org.chainmaker.sdk.utils.FileUtils;
import org.yaml.snakeyaml.Yaml;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class InitClient {

    static String TLS_HOST_NAME = "chainmaker.org";
    static int CONNECT_COUNT = 10;

    // resources 下路径
    static String ADMIN1_PK_PATH = "crypto-config/wx-org1.chainmaker.org/admin/admin.key";
    static String ADMIN2_PK_PATH = "crypto-config/wx-org2.chainmaker.org/admin/admin.key";
    static String ADMIN3_PK_PATH = "crypto-config/wx-org3.chainmaker.org/admin/admin.key";
    static String ADMIN4_PK_PATH = "crypto-config/wx-org4.chainmaker.org/admin/admin.key";

    private static final String CHAIN_ID = "chain1";
    private static final int MAX_MESSAGE_SIZE = 16;

    static String ORG_ID1 = "wx-org1.chainmaker.org";
    static String ORG_ID2 = "wx-org2.chainmaker.org";
    static String ORG_ID3 = "wx-org3.chainmaker.org";
    static String ORG_ID4 = "wx-org4.chainmaker.org";

    static String NODE_GRPC_URL = "59.110.154.31:12301";

    static String TYPE = "mysql";
    static String DEST = "root:123456:localhost:3306";
    static String SECRET_KEY = "xxx";

    static String SDK_CONFIG = "sdk_config_pwk.yml";

    static ChainClient chainClient;
    static ChainManager chainManager;

    static User adminUser1;
    static User adminUser2;
    static User adminUser3;
    static User adminUser4;

    static String CLIENT_KEY_PATH =
            "src/main/resources/crypto-config/wx-org1.chainmaker.org/user/client1/client1.key";

    /**
     * 配置文件初始化client
     *
     * @throws Exception
     */
    public static void inItChainClient() throws Exception {

        Yaml yaml = new Yaml();
        InputStream in = InitClient.class.getClassLoader().getResourceAsStream(SDK_CONFIG);

        SdkConfig sdkConfig;
        sdkConfig = yaml.loadAs(in, SdkConfig.class);
        assert in != null;
        in.close();

        for (NodeConfig nodeConfig : sdkConfig.getChainClient().getNodes()) {
            List<byte[]> tlsCaCertList = new ArrayList<>();
            if (nodeConfig.getTrustRootPaths() != null) {
                for (String rootPath : nodeConfig.getTrustRootPaths()) {
                    List<String> filePathList = FileUtils.getFilesByPath(rootPath);
                    for (String filePath : filePathList) {
                        tlsCaCertList.add(FileUtils.getFileBytes(filePath));
                    }
                }
            }
            byte[][] tlsCaCerts = new byte[tlsCaCertList.size()][];
            tlsCaCertList.toArray(tlsCaCerts);
            nodeConfig.setTrustRootBytes(tlsCaCerts);
        }

        chainManager = ChainManager.getInstance();
        chainClient = chainManager.getChainClient(sdkConfig.getChainClient().getChainId());

        if (chainClient == null) {
            chainClient = chainManager.createChainClient(sdkConfig);
        }

        // 背书用户，各个组织的admin
        adminUser1 = new User(ORG_ID1);
        adminUser1.setAuthType(AuthType.PermissionedWithKey.getMsg());
        adminUser1.setPriBytes(FileUtils.getResourceFileBytes(ADMIN1_PK_PATH));

        adminUser2 = new User(ORG_ID2);
        adminUser2.setAuthType(AuthType.PermissionedWithKey.getMsg());
        adminUser2.setPriBytes(FileUtils.getResourceFileBytes(ADMIN2_PK_PATH));

        adminUser3 = new User(ORG_ID3);
        adminUser3.setAuthType(AuthType.PermissionedWithKey.getMsg());
        adminUser3.setPriBytes(FileUtils.getResourceFileBytes(ADMIN3_PK_PATH));

        adminUser4 = new User(ORG_ID4);
        adminUser4.setAuthType(AuthType.PermissionedWithKey.getMsg());
        adminUser4.setPriBytes(FileUtils.getResourceFileBytes(ADMIN4_PK_PATH));
    }

    /**
     * 无配置文件初始化客户端
     *
     * <p>NFT持有者充当调用者，需要使用这个方法
     *
     * <p>实现外部私钥用户发起链调用，用户需要先使用管理员添加到链上，才能发起调用
     *
     * @throws SdkException
     */
    public static void initWithNoConfig() throws SdkException {

        SdkConfig sdkConfig = new SdkConfig();
        ChainClientConfig chainClientConfig = new ChainClientConfig();
        sdkConfig.setChainClient(chainClientConfig);

        RpcClientConfig rpcClientConfig = new RpcClientConfig();
        rpcClientConfig.setMaxReceiveMessageSize(MAX_MESSAGE_SIZE);

        ArchiveConfig archiveConfig = new ArchiveConfig();
        archiveConfig.setDest(DEST);
        archiveConfig.setType(TYPE);
        archiveConfig.setSecretKey(SECRET_KEY);

        NodeConfig nodeConfig = new NodeConfig();
        nodeConfig.setNodeAddr(NODE_GRPC_URL);
        nodeConfig.setConnCnt(CONNECT_COUNT);
        nodeConfig.setTrustRootPaths(new String[] {});

        NodeConfig[] nodeConfigs = new NodeConfig[] {nodeConfig};

        chainManager = ChainManager.getInstance();
        chainClient = chainManager.getChainClient(CHAIN_ID);

        chainClientConfig.setOrgId(ORG_ID1);
        chainClientConfig.setChainId(CHAIN_ID);
        chainClientConfig.setAuthType("permissionedWithKey");
        chainClientConfig.setUserSignKeyFilePath(CLIENT_KEY_PATH);
        chainClientConfig.setRpcClient(rpcClientConfig);
        chainClientConfig.setArchive(archiveConfig);
        chainClientConfig.setNodes(nodeConfigs);

        if (chainClient == null) {
            chainClient = chainManager.createChainClient(sdkConfig);
        }

        // 背书用户
        adminUser1 = new User(ORG_ID1);
        adminUser1.setAuthType(AuthType.PermissionedWithKey.getMsg());
        adminUser1.setPriBytes(FileUtils.getResourceFileBytes(ADMIN1_PK_PATH));

        adminUser2 = new User(ORG_ID2);
        adminUser2.setAuthType(AuthType.PermissionedWithKey.getMsg());
        adminUser2.setPriBytes(FileUtils.getResourceFileBytes(ADMIN2_PK_PATH));

        adminUser3 = new User(ORG_ID3);
        adminUser3.setAuthType(AuthType.PermissionedWithKey.getMsg());
        adminUser3.setPriBytes(FileUtils.getResourceFileBytes(ADMIN3_PK_PATH));

        adminUser4 = new User(ORG_ID4);
        adminUser4.setAuthType(AuthType.PermissionedWithKey.getMsg());
        adminUser4.setPriBytes(FileUtils.getResourceFileBytes(ADMIN4_PK_PATH));
    }
}

Contract

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
package chainmaker.sdk.demo;

import org.bouncycastle.util.encoders.Hex;
import org.chainmaker.pb.common.ContractOuterClass;
import org.chainmaker.pb.common.Request;
import org.chainmaker.pb.common.ResultOuterClass;
import org.chainmaker.sdk.ChainClient;
import org.chainmaker.sdk.SdkException;
import org.chainmaker.sdk.User;
import org.chainmaker.sdk.utils.CryptoUtils;
import org.chainmaker.sdk.utils.FileUtils;
import org.chainmaker.sdk.utils.SdkUtils;
import org.chainmaker.sdk.utils.Utils;
import org.web3j.abi.FunctionEncoder;
import org.web3j.abi.datatypes.*;
import org.web3j.abi.datatypes.generated.Bytes1;
import org.web3j.utils.Numeric;

import java.io.IOException;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class Contract {

    private static final String QUERY_CONTRACT_METHOD = "query";

    private static final String CONTRACT_ARGS_EVM_PARAM = "data";

    // resources 下路径
    private static final String EVM_CONTRACT_FILE_PATH = "ERC1155MixedFungibleMintable.bin";
    private static final String CONTRACT_NAME = "ERC1155";

    private static String ADDRESS = "";

    /**
     * 根据公钥获取用户地址
     *
     * @param chainClient
     */
    private static void makeAddrFromCert(ChainClient chainClient) {
        try {
            //            ADDRESS =
            // CryptoUtils.makeAddrFromCert(chainClient.getClientUser().getCertificate());
            ADDRESS = CryptoUtils.makeAddrFromPukPem(chainClient.getClientUser().getPublicKey());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建合约
     *
     * @param chainClient
     * @param adminUser1
     * @param adminUser2
     * @param adminUser3
     * @param adminUser4
     */
    public static void createContract(
            ChainClient chainClient,
            User adminUser1,
            User adminUser2,
            User adminUser3,
            User adminUser4) {

        // 计算公钥地址
        // 此地址是当前调用者的链上地址
        makeAddrFromCert(chainClient);

        // 创建合约构造参数扽RLP编码值
        Function function =
                new Function("", Arrays.asList(new Address(ADDRESS)), Collections.emptyList());
        String methodDataStr = FunctionEncoder.encode(function);

        Map<String, byte[]> paramMap = new HashMap<>();
        paramMap.put(CONTRACT_ARGS_EVM_PARAM, methodDataStr.substring(10).getBytes());

        ResultOuterClass.TxResponse responseInfo = null;
        try {
            byte[] byteCode = FileUtils.getResourceFileBytes(EVM_CONTRACT_FILE_PATH);
            // 1. create payload
            Request.Payload payload =
                    chainClient.createContractCreatePayload(
                            Utils.calcContractName(CONTRACT_NAME),
                            "1.0",
                            Hex.decode(new String(byteCode)),
                            ContractOuterClass.RuntimeType.EVM,
                            paramMap);

            // 2. create payloads with endorsement
            Request.EndorsementEntry[] endorsementEntries =
                    SdkUtils.getEndorsers(
                            payload, new User[] {adminUser1, adminUser2, adminUser3, adminUser4});

            // 3. send request
            responseInfo =
                    chainClient.sendContractManageRequest(
                            payload, endorsementEntries, 10000, 10000);
        } catch (SdkException e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
    }

    public static void queryContract(ChainClient chainClient) {

        ResultOuterClass.TxResponse responseInfo = null;

        try {
            responseInfo =
                    chainClient.queryContract(
                            CONTRACT_NAME, QUERY_CONTRACT_METHOD, null, null, 10000);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
    }

    /**
     * 合约方法 create
     *
     * @param chainClient
     */
    public static void create(ChainClient chainClient) {

        ResultOuterClass.TxResponse responseInfo = null;

        // 计算公钥地址
        makeAddrFromCert(chainClient);

        Map<String, byte[]> params = new HashMap<>();

        Function function =
                new Function(
                        "create",
                        Arrays.asList(new Utf8String("yegetaier"), new Bool(true)),
                        Collections.emptyList());

        String methodDataStr = FunctionEncoder.encode(function);

        String method = methodDataStr.substring(0, 10);

        params.put(CONTRACT_ARGS_EVM_PARAM, methodDataStr.getBytes());

        try {
            responseInfo =
                    chainClient.invokeContract(
                            Utils.calcContractName(CONTRACT_NAME),
                            method,
                            null,
                            params,
                            100000,
                            100000);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
        System.out.println(
                Numeric.toBigInt(responseInfo.getContractResult().getResult().toByteArray()));
    }

    /**
     * 合约方法 creators
     *
     * <p>此方法可以用于查询当前调用者的链上地址 与SDK计算的地址比较 可判断SDK计算的地址和链上实际地址是否一致
     *
     * @param chainClient
     */
    public static void creators(ChainClient chainClient) {

        ResultOuterClass.TxResponse responseInfo = null;

        // 计算公钥地址
        makeAddrFromCert(chainClient);

        Map<String, byte[]> params = new HashMap<>();

        Function function =
                new Function(
                        "creators",
                        Arrays.asList(
                                new Uint(
                                        new BigInteger(
                                                "57896044618658097711785492504343953927315557066662158946655541218820101242880"))),
                        Collections.emptyList());

        String methodDataStr = FunctionEncoder.encode(function);

        String method = methodDataStr.substring(0, 10);

        params.put(CONTRACT_ARGS_EVM_PARAM, methodDataStr.getBytes());

        try {
            responseInfo =
                    chainClient.invokeContract(
                            Utils.calcContractName(CONTRACT_NAME),
                            method,
                            null,
                            params,
                            100000,
                            100000);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
        System.out.println(
                Numeric.toHexString(responseInfo.getContractResult().getResult().toByteArray()));
    }

    /**
     * 合约方法 mint
     *
     * @param chainClient
     */
    public static void mint(ChainClient chainClient) {

        ResultOuterClass.TxResponse responseInfo = null;

        // 计算公钥地址
        makeAddrFromCert(chainClient);

        Map<String, byte[]> params = new HashMap<>();

        Function function =
                new Function(
                        "mintNonFungible",
                        Arrays.asList(
                                new Uint(
                                        new BigInteger(
                                                "57896044618658097711785492504343953927315557066662158946655541218820101242880")),
                                new DynamicArray(
                                        new Address("0xe208986344362d1598169b1c0958d81a9a04abdb"))),
                        Collections.emptyList());

        String methodDataStr = FunctionEncoder.encode(function);

        String method = methodDataStr.substring(0, 10);

        params.put(CONTRACT_ARGS_EVM_PARAM, methodDataStr.getBytes());

        try {
            responseInfo =
                    chainClient.invokeContract(
                            Utils.calcContractName(CONTRACT_NAME),
                            method,
                            null,
                            params,
                            100000,
                            100000);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
        System.out.println(
                Numeric.toBigInt(responseInfo.getContractResult().getResult().toByteArray()));
        System.out.println(
                Numeric.toHexString(responseInfo.getContractResult().getResult().toByteArray()));
    }

    /**
     * 合约方法 ownerOf
     *
     * @param chainClient
     */
    public static void ownerOf(ChainClient chainClient) {

        ResultOuterClass.TxResponse responseInfo = null;

        // 计算公钥地址
        makeAddrFromCert(chainClient);

        Map<String, byte[]> params = new HashMap<>();

        Function function =
                new Function(
                        "ownerOf",
                        Arrays.asList(
                                new Uint(
                                        new BigInteger(
                                                "57896044618658097711785492504343953927315557066662158946655541218820101242881"))),
                        Collections.emptyList());

        String methodDataStr = FunctionEncoder.encode(function);

        String method = methodDataStr.substring(0, 10);

        params.put(CONTRACT_ARGS_EVM_PARAM, methodDataStr.getBytes());

        try {
            responseInfo =
                    chainClient.invokeContract(
                            Utils.calcContractName(CONTRACT_NAME),
                            method,
                            null,
                            params,
                            100000,
                            100000);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
        System.out.println(
                Numeric.toBigInt(responseInfo.getContractResult().getResult().toByteArray()));
        System.out.println(
                Numeric.toHexString(responseInfo.getContractResult().getResult().toByteArray()));
    }

    /**
     * 添加公钥用户
     *
     * @param chainClient
     * @param adminUser1
     * @param adminUser2
     * @param adminUser3
     * @param adminUser4
     */
    public static void addPukUser(
            ChainClient chainClient,
            User adminUser1,
            User adminUser2,
            User adminUser3,
            User adminUser4) {

        String ORG_ID = "wx-org1.chainmaker.org";
        String ROLE = "client";

        ResultOuterClass.TxResponse responseInfo = null;
        try {
            String pubKey =
                    "-----BEGIN PUBLIC KEY-----\n"
                            + "MIIBCgKCAQEAvCSNF0ONr+4ZUP06jIH3BY3HBEekDlGS7hPRe30PHpFkKCVVIaWk\n"
                            + "9tE9fKhYArVRLVKa3KsLJMbDhjPIc6nO2ELtDY8fBnd2usXWgNQsitNIqlVASE5T\n"
                            + "/ph1ukmWnw7ec8J0wWSb+xzfDopDEDl4HnV2h0oHT24MlcZsz66LFuRTqo7gtofn\n"
                            + "glAG4C6O/WGaEW9i8qqV3gyXVWD7AXv1iFHS1FOpSGu7sG7UaJLGooEd58tvAl1C\n"
                            + "6UvTLrl83/WXjS74lH7P3BaLR6/7nzQu6B+HDPR7e0Rmqr6LmPrugurmct8/ZjeA\n"
                            + "4tSbMrpYdaaAXPXCZuAS74tw0cLz0P29sQIDAQAB\n"
                            + "-----END PUBLIC KEY-----\n";

            Request.Payload payload = chainClient.createPubkeyAddPayload(pubKey, ORG_ID, ROLE);

            Request.EndorsementEntry[] endorsementEntries =
                    SdkUtils.getEndorsers(
                            payload, new User[] {adminUser1, adminUser2, adminUser3, adminUser4});

            responseInfo =
                    chainClient.sendPubkeyManageRequest(payload, endorsementEntries, 1000, 1000);
        } catch (SdkException e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
    }

    /**
     * 合约方法 safeTransferFrom
     *
     * @param chainClient
     */
    public static void safeTransferFrom(ChainClient chainClient) {

        ResultOuterClass.TxResponse responseInfo = null;

        // address根据用户证书生成
        makeAddrFromCert(chainClient);

        Map<String, byte[]> params = new HashMap<>();

        Function function =
                new Function(
                        "safeTransferFrom",
                        Arrays.asList(
                                new Address("0xe208986344362d1598169b1c0958d81a9a04abdb"),
                                new Address("0xd718a2c0f091f8dc790846815c110aea42ee4fce"),
                                new Uint(
                                        new BigInteger(
                                                "57896044618658097711785492504343953927315557066662158946655541218820101242881")),
                                new Uint(new BigInteger("1")),
                                new Bytes1("1".getBytes(StandardCharsets.UTF_8))),
                        Collections.emptyList());

        String methodDataStr = FunctionEncoder.encode(function);

        String method = methodDataStr.substring(0, 10);

        params.put(CONTRACT_ARGS_EVM_PARAM, methodDataStr.getBytes());

        try {
            responseInfo =
                    chainClient.invokeContract(
                            Utils.calcContractName(CONTRACT_NAME),
                            method,
                            null,
                            params,
                            100000,
                            100000);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
        System.out.println(
                Numeric.toBigInt(responseInfo.getContractResult().getResult().toByteArray()));
        System.out.println(
                Numeric.toHexString(responseInfo.getContractResult().getResult().toByteArray()));
    }

    /**
     * 合约方法 setApprovalForAll
     *
     * @param chainClient
     */
    public static void setApprovalForAll(ChainClient chainClient) {

        ResultOuterClass.TxResponse responseInfo = null;

        // 计算公钥地址
        makeAddrFromCert(chainClient);
        System.out.println(ADDRESS);

        Map<String, byte[]> params = new HashMap<>();

        Function function =
                new Function(
                        "setApprovalForAll",
                        Arrays.asList(
                                new Address("0xd718a2c0f091f8dc790846815c110aea42ee4fce"),
                                new Bool(true)),
                        Collections.emptyList());

        String methodDataStr = FunctionEncoder.encode(function);

        String method = methodDataStr.substring(0, 10);

        params.put(CONTRACT_ARGS_EVM_PARAM, methodDataStr.getBytes());

        try {
            responseInfo =
                    chainClient.invokeContract(
                            Utils.calcContractName(CONTRACT_NAME),
                            method,
                            null,
                            params,
                            100000,
                            100000);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
        System.out.println(
                Numeric.toBigInt(responseInfo.getContractResult().getResult().toByteArray()));
        System.out.println(
                Numeric.toHexString(responseInfo.getContractResult().getResult().toByteArray()));
    }

    /**
     * 合约方法 isApprovedForAll
     *
     * <p>此方法可判断链上地址和SDK计算地址是否一致
     *
     * <p>如果授权成功 输入SDK计算的地址，但是返回0，说明SDK计算的地址和链上实际地址不一样
     *
     * @param chainClient
     */
    public static void isApprovedForAll(ChainClient chainClient) {

        ResultOuterClass.TxResponse responseInfo = null;

        // 计算公钥地址
        makeAddrFromCert(chainClient);

        Map<String, byte[]> params = new HashMap<>();

        Function function =
                new Function(
                        "isApprovedForAll",
                        Arrays.asList(
                                new Address("0xe208986344362d1598169b1c0958d81a9a04abdb"),
                                new Address("0xd718a2c0f091f8dc790846815c110aea42ee4fce")),
                        Collections.emptyList());

        String methodDataStr = FunctionEncoder.encode(function);

        String method = methodDataStr.substring(0, 10);

        params.put(CONTRACT_ARGS_EVM_PARAM, methodDataStr.getBytes());

        try {
            responseInfo =
                    chainClient.invokeContract(
                            Utils.calcContractName(CONTRACT_NAME),
                            method,
                            null,
                            params,
                            100000,
                            100000);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(responseInfo);
        System.out.println(
                Numeric.toBigInt(responseInfo.getContractResult().getResult().toByteArray()));
        System.out.println(
                Numeric.toHexString(responseInfo.getContractResult().getResult().toByteArray()));
    }
}

Django

根据已有数据库表生成 model 类

1
2
3
4
# 生成model
python manage.py inspectdb
# 导入应用，app为应用名
python manage.py inspectdb > app/models.py

单例注入

单例必须注入全局变量，使用的时候从全局变量导入过来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Client(object):
    # Chain客户端
    _instance = None
    # 不加锁，在多线程环境下会创建多个实例
    lock = threading.Lock()
    init_flag = False

    # 初始化客户端
    # 只存在一个客户端
    def __new__(cls, *args, **kw):
        if not cls._instance:
            with cls.lock:
                sdk_config_file = os.path.join(settings.STATICFILES_DIRS[0], 'sdk_config_pwk.yml')
                # os.chdir(cls.config_dir)
                cls._instance = ChainClient.from_conf(sdk_config_file)
        return cls._instance

    def __init__(self):
        with self.__class__.lock:
            if not self.__class__.init_flag:
                self.__class__.init_flag = True

# 使用
cc = Client()

# 测试
# 多次循环请求
# 发现每次计算的testx都为True
cc = Client()
def index(request):
    cc1 = Client()
    cc2 = Client()
    test1 = cc1 == cc2
    test2 = cc1 is cc2
    test3 = cc == cc1
    test4 = cc is cc1
    return HttpResponse("Hello, world. You're at the polls index.")
  1. 在你创建的项目中，找到 settings.py 文件
  2. 文件 settings.py 找到 MIDDLEWARE 参数
  3. 注释掉'django.middleware.csrf.CsrfViewMiddleware', 即可

统一异常处理

异常处理类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# middlewares.py

# !/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author: 曳戈泰尔
# @Desc: { 项目中间件模块-全局异常处理 }
# @Date: 2022/10/24 18:18
from django.http import HttpResponse
from django.middleware.common import MiddlewareMixin
import json


class ExceptionMiddleware(MiddlewareMixin):
    """统一异常处理中间件"""

    def process_exception(self, request, exception):
        """
        统一异常处理
        :param request: 请求对象
        :param exception: 异常对象
        :return:
        """

        # 打印异常
        print(exception)

        # 异常处理
        return_json = {
            'code': 2,
            'status': 'FAIL',
            'message': '捕获到异常',
            'data': str(exception)
        }
        return HttpResponse(json.dumps(return_json))
        # return None

配置（erc1155为应用目录）

1
2
3
4
5
6
7
8
9
10
11
12
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',

    # 指定异常中间件
    'erc1155.middlewares.ExceptionMiddleware'
]

异步（有bug）

参考异步视图：https://zhuanlan.zhihu.com/p/250187291，异步任务+异步视图实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 异步任务
async def http_call_async():
    for num in range(1, 6):
        await asyncio.sleep(1)
        print(num)
    async with httpx.AsyncClient() as client:
        r = await client.get("https://httpbin.org/")
        print(r)

# 异步视图 - 调用异步任务
async def async_view(request):
    loop = asyncio.get_event_loop()
    loop.create_task(http_call_async())
    return HttpResponse("Non-blocking HTTP request")

# 更新 urls.py：
urlpatterns = [
    path("async/", async_view),
]

# 浏览器访问 http://localhost:8000/async/
终端日志
INFO:     127.0.0.1:60374 - "GET /async/ HTTP/1.1" 200 OK
1
2
3
4
5
<Response [200 OK]>
说明：HTTP 响应在第一个异步任务执行之前已经返回。HTTP 响应返回后，异步任务仍在执行，直到结束。

多线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
from django.shortcuts import render
from .models import PersonInfo
from concurrent.futures import ThreadPoolExecutor
import datetime, time
 
def indexView(request):
    startTime = datetime.datetime.now()
    print(startTime)
    title = '单线程'
    results = []
    for i in range(2):
        person = PersonInfo.objects.filter(id=int(i+1)).first()
        time.sleep(3)
        results.append(person)
    endTime = datetime.datetime.now()
    print(endTime)
    print('单线程查询所花费时间', endTime-startTime)
    return render(request, 'index.html', locals())

# 定义多线程任务
def get_info(id):
    person = PersonInfo.objects.filter(id=int(id)).first()
    time.sleep(3)
    return person

def threadIndexView(request):
    # 计算运行时间
    startTime = datetime.datetime.now()
    print(startTime)
    title = '多线程'
    Thread = ThreadPoolExecutor(max_workers=2)
    results = []
    fs = []
    # 执行多线程
    for i in range(2):
        t = Thread.submit(get_info, i + 1)
        fs.append(t)
    # 获取多线程的执行结果
    for t in fs:
        results.append(t.result())
    # 计算运行时间
    endTime = datetime.datetime.now()
    print(endTime)
    print('多线程查询所花费时间', endTime-startTime)
    return render(request, 'index.html', locals())

部署Ubuntu

因SDK服务为内部服务，所以没有使用Nginx代理。部署模式：Django+Anaconda+uwsgi。

修改时区

修改时区为东八区（上海时间）

1
2
3
4
5
6
7
8
TIME_ZONE = 'Asia/Shanghai'

USE_I18N = True

# 注释这里即可
# USE_TZ = True

# 获取时间 django.utils.timezone.now()

关闭DEBUG

1
2
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False

RSA生成加速

RSA生成不同长度公私钥的时间对比

pip install rsa

（数字越大生成的速度越慢）

生成加速需要增加进程，通过 poolsize=8 设置多进程。

更换生成方法，借助OpenSSL生成

pip install pyOpenSSL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from OpenSSL.crypto import PKey
from OpenSSL.crypto import TYPE_RSA, FILETYPE_PEM
from OpenSSL.crypto import dump_privatekey, dump_publickey

pk = PKey()
pk.generate_key(TYPE_RSA, 2048)

pub = dump_publickey(FILETYPE_PEM, pk)
pri = dump_privatekey(FILETYPE_PEM, pk)

pubString = str(pub, encoding="utf-8")
print(pubString)

priString = str(pri, encoding="utf-8")
print(priString)

性能优化

查看cpu个数：cat /proc/cpuinfo |grep "processor"|wc -l，CPU个数一般等于processes

计算threads：

根据 linux 的默认进程和线程大小计算：
默认一个进程的堆栈大小是 2GB
默认一个线程的堆栈大小是 1MB
所以一个进程可以开 2G/1M=2048 个线程，但实际上内存当然不可能完全拿来作线程的栈，所以实际数目要比这个值要小，一般情况会达到 1500 个线程。

设置listen

如果没有设置 uwsgi 的 –listen，如果 sysctl -a | grep net.core.somaxconn 发现 net.core.somaxconn=128。

那你使用 uwsgi 启动的服务，单机最大支持并发数为 100*(启动的 uwsgi 进程数)。

如果启动进程为 4 个，则最大并发只能支持 400，这样会在 uwsgi 的 log 日志中出现错误 uWSGI listen queue of socket 4 full。

同时，nginx 对应也会出现错误 ***** upstream time out。

修补措施：

临时生效

sysctl -w net.core.somaxconn=32768
sysctl -w net.ipv4.tcp_max_syn_backlog=8192

永久生效

vi /etc/sysctl.conf
net.core.somaxconn=32768
net.ipv4.tcp_max_syn_backlog=8192
:wq
执行 sysctl -p 重新 load 参数设置，这样会立即生效，并且以后重新启动机器也会生效。

查看是否修改成功
sysctl -a
sysctl -a | grep net.core.somaxconn

设置 uwsgi 启动的 –listen 10000

Django性能优化，uwsgi.ini见下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

[uwsgi]

# Django-related settings
# the base directory (full path)
chdir           = /root/chainMaker-application/chainMaker
# Django's wsgi file
module          = chainMaker.wsgi
# the virtualenv (full path)
# Anaconda环境
home            = /root/anaconda3/envs/chainMaker
# process-related settings
# master
master          = true
# maximum number of worker processes
processes       = 1
# 开启多线程
enable-threads 	= true
threads					= 1000
listen					= 10000
# pid file
pidfile         = /root/chainMaker-application/chainMaker/uwsgi/uwsgi.pid
# The address and port of the monitor
http            = :8000
# clear environment on exit
vacuum          = true
# The process runs in the background and types the log to the specified log file
daemonize       = /root/chainMaker-application/chainMaker/uwsgi/uwsgi.log

日志切割

uwsgi.ini

1
2
3
4
5
6
7
# 修改及增加
# log 在 master 中处理，不设置这个，日志切割有时会中断，导致日志丢失
log-master = true
# The process runs in the background and types the log to the specified log file
daemonize = /root/chainMaker-application/chainMaker/logs/uwsgi.log
# 设置一个监听对象
touch-logreopen = /root/chainMaker-application/chainMaker/logs/.touchforlogrotat

/root/chainMaker-application/chainMaker/logs/uwsgi_log_cut.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#!/bin/bash
LOGDIR="/root/chainMaker-application/chainMaker/logs"    #当前日志所在目录
DATE=`date -d "yesterday" +%Y.%m.%d`
NEW_DIR="/root/chainMaker-application/chainMaker/logs/history"   #新建文件夹history用来放旧日志
mkdir -p ${NEW_DIR}
mv ${LOGDIR}/uwsgi.log ${NEW_DIR}/uwsgi.${DATE}.log   #将旧日志重新以日期命名
touch /root/chainMaker-application/chainMaker/logs/.touchforlogrotat


# crontab表达式
# crontab -e
# 修改文件执行权限. 执行命令: sudo chmod +x /xxx/uwsgi_log_cut.sh （必须）
# 每天0点执行脚本 uwsgi_log_cut.sh
# 0 0 * * * sh /root/chainMaker-application/chainMaker/logs/uwsgi_log_cut.sh
# Esc+A保存
# 查看当前作业：crontab -l

/root/chainMaker-application/chainMaker/logs/clean_log.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#!/bin/bash
# 脚本功能：
# 每周1, 清理一次7天前生成的日志

find /root/chainMaker-application/chainMaker/logs/history -type f -mtime +7 | xargs rm -f

# 使用说明：
# 1. 修改文件执行权限. 执行命令: sudo chmod +x /xxx/clean_log.sh （必须）
# 2. 配置任务，每周一凌晨1点. 执行命令：
# sudo crontab -e , 在打开窗口输入：
# 0 1 * * MON sh /root/chainMaker-application/chainMaker/logs/clean_log.sh
# Esc+A保存
# 查看当前作业：crontab -l

区块链浏览器实现（PWK）

explorer-backend

修改非配置文件创建client为配置文件创建client

拷贝配置文件：crypto-config，sdk_config_pwk_org1_admin.yml

sdk_config_pwk_org1_admin.yml 内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
chain_client:
  # 链ID
  chain_id: "chain1"
  # 组织ID
  org_id: "wx-org1.chainmaker.org"

  # 客户端用户交易签名私钥路径
  user_sign_key_file_path: "configs/crypto-config/wx-org1.chainmaker.org/admin/admin.key"
  # 签名使用的哈希算法，和节点保持一直
  crypto:
    hash: SHA256
  auth_type: permissionedWithKey

  nodes:
    - # 节点地址，格式为：IP:端口:连接数
      node_addr: "59.110.154.31:12301"
      # 节点连接数
      conn_cnt: 10

  archive:
    # 数据归档链外存储相关配置
    type: "mysql"
    dest: "root:123456:localhost:3306"
    secret_key: xxx

  rpc_client:
    max_receive_message_size: 16 # grpc客户端接收消息时，允许单条message大小的最大值(MB)
    max_send_message_size: 16 # grpc客户端发送消息时，允许单条message大小的最大值(MB)
    send_tx_timeout: 60 # grpc 客户端发送交易超时时间
    get_tx_timeout: 60 # rpc 客户端查询交易超时时间

chain_client.go 修改为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/*
Copyright (C) THL A29 Limited, a Tencent company. All rights reserved.

SPDX-License-Identifier: Apache-2.0
*/
package sync

import (
	commonlog "chainmaker.org/chainmaker/common/v2/log"
	sdk "chainmaker.org/chainmaker/sdk-go/v2"
	"chainmaker_web/src/dao"
	"go.uber.org/zap"
)

const ConnCount = 10

const (
	sdkConfigOrg1AdminPath = "configs/sdk_config_pwk_org1_admin.yml"
)

// CreateSdkClientWithChainId return Sdk chain client with chain-id
func CreateChainClient(sdkConfig *dao.Subscribe) (*sdk.ChainClient, error) {

	//remote := sdkConfig.Remote
	//nodeOptions := make([]sdk.ChainClientOption, 0)
	//
	//nodeOptions = append(nodeOptions, sdk.WithChainClientOrgId(sdkConfig.OrgId))
	//
	//nodeOptions = append(nodeOptions, sdk.WithChainClientChainId(sdkConfig.ChainId))
	//
	//nodeOptions = append(nodeOptions, sdk.WithUserKeyBytes([]byte(sdkConfig.UserKey)))
	//nodeOptions = append(nodeOptions, sdk.WithUserCrtBytes([]byte(sdkConfig.UserCert)))
	//
	//nodeOptions = append(nodeOptions, sdk.WithUserSignKeyBytes([]byte(sdkConfig.UserKey)))
	//nodeOptions = append(nodeOptions, sdk.WithUserSignCrtBytes([]byte(sdkConfig.UserCert)))
	//
	//nodeOptions = append(nodeOptions, sdk.WithAuthType("permissionedwithkey"))
	//
	//// 增加哈希算法
	//hashConfig := sdk.WithHashAlgo("SHA256")
	//
	//rpcClient := sdk.NewRPCClientConfig(
	//	sdk.WithRPCClientMaxReceiveMessageSize(100),
	//)
	//
	//nodeOptions = append(nodeOptions, sdk.WithRPCClientConfig(rpcClient))
	//
	//conf := &sdk.Pkcs11Config{
	//	Enabled: false,
	//}
	//nodeOptions = append(nodeOptions, sdk.WithPkcs11Config(conf))
	//
	//node := sdk.NewNodeConfig(
	//	// 节点地址，格式：127.0.0.1:12301
	//	sdk.WithNodeAddr(remote),
	//	// 节点连接数
	//	sdk.WithNodeConnCnt(ConnCount),
	//	// 节点是否启用TLS认证
	//	sdk.WithNodeUseTLS(sdkConfig.Tls),
	//	// 根证书路径，支持多个
	//	sdk.WithNodeCACerts([]string{sdkConfig.NodeCACert}),
	//	// TLS Hostname
	//	sdk.WithNodeTLSHostName(sdkConfig.TlsHost),
	//)
	//nodeOptions = append(nodeOptions, sdk.AddChainClientNodeConfig(node))
	//nodeOptions = append(nodeOptions, sdk.WithChainClientLogger(getDefaultLogger()))

	//chainClient, err := sdk.NewChainClient(nodeOptions...)

	chainClient, err := sdk.NewChainClient(sdk.WithConfPath(sdkConfigOrg1AdminPath))
	if err != nil {
		return nil, err
	}

	return chainClient, nil
}

func getDefaultLogger() *zap.SugaredLogger {
	configInfo := commonlog.LogConfig{
		Module:       "[SDK]",
		LogPath:      "log/sdk.log",
		LogLevel:     commonlog.LEVEL_DEBUG,
		MaxAge:       30,
		JsonFormat:   false,
		ShowLine:     true,
		LogInConsole: false,
	}

	logger, _ := commonlog.InitSugarLogger(&configInfo)
	return logger
}

修改docker-comopose.yml

  • 指定数据库端口映射
  • 指定数据库挂载目录（数据盘挂载目录下）
  • 修改数据库默认密码
  • 修改Web端暴露端口
  • 分离MySQL为独立docker-compose
  • 分离explorer_web为独立docker-compose
  • 注释容器依赖depends_on
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
version: "3.9"

services:
  #  cm_explorer_db:
  #    image: mysql:5.7
  #    ports:
  #      - "3306:3306"
  #    volumes:
  #      - explorer_db_data:/home/docker/volumes/mysql3306
  #    restart: always
  #    environment:
  #      MYSQL_ROOT_PASSWORD: Baec&chainmaker
  #      MYSQL_USER: chainmaker@yqxc
  #      MYSQL_PASSWORD: Baec&chainmaker@yqxc
  #      MYSQL_DATABASE: chainmaker_explorer_dev
  #    command: [ 'mysqld', '--character-set-server=utf8mb4', '--collation-server=utf8mb4_unicode_ci' ]

  cm_explorer_server:
    image: chainmakerofficial/explorer-backend:v2.2.0
    #    depends_on:
    #      - cm_explorer_db
    ports:
      - "9997:9997"
    restart: always

  #  cm_explorer_web:
  #    #      depends_on:
  #    #        - cm_explorer_server
  #    image: chainmakerofficial/explorer-web:v2.2.1
  #    ports:
  #      - "80:8080"
  #    restart: always

volumes:
  explorer_db_data: { }

修改config.yml

  • 修改数据库用户名 / 密码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
web:
  address:  0.0.0.0
  port:     9997
  cross_domain:     true

node:
  #  链和节点更新时间
  update_time: 30
  #  节点断开连接时间和新增链时间
  sync_time:   30


db:
#  host: cm_explorer_db
  host: 59.110.154.31
  port: 3306
  database: chainmaker_explorer_dev
  user:   chainmaker@yqxc
  passwd: Baec&chainmaker@yqxc

修改配置文件路径

  • 这两个路径在本地GoLand调试是正常的，但是docker打包运行不正常。
1
2
3
4
const (
	sdkConfigOrg1AdminPath = "configs/sdk_config_pwk_org1_admin.yml"
)
user_sign_key_file_path: "configs/crypto-config/wx-org1.chainmaker.org/admin/admin.key"
  • 打包运行时，需要修改这两个路径，具体修改参考Dockerfile：
1
2
3
4
5
# docker下针对go运行bin的相对路径
const (
	sdkConfigOrg1AdminPath = "../configs/sdk_config_pwk_org1_admin.yml"
)
user_sign_key_file_path: "../configs/crypto-config/wx-org1.chainmaker.org/admin/admin.key"

部署

  • docker镜像image的save和load方法针对相同的操作系统，否则load之后运行image会报错，建议拷贝项目到服务器再docker打包镜像image。
  • 修改项目名称为chainmaker-explorer-server
  • docker-build命令详见Makefile文件，注意镜像版本version需要与docker-compose一致。
  • 打包完成，到docker目录，docker-compose up命令启动。

server初始化

执行curl请求，或者ApiFox执行，或者Web端执行（路径：/addchain），完成explorer-server的初始化。
推荐Web可视化执行——等explorer-web部署启动，直接访问首页，首页找不到则追加路径/addchain。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 服务IP：59.110.154.31（建议设置内网IP）
# pem证书字符串的回车用\n替换
curl --location --request POST 'http://59.110.154.31:9997/chainmaker/?cmb=SubscribeChain' \
--header 'User-Agent: apifox/1.0.0 (https://www.apifox.cn)' \
--header 'Content-Type: application/json' \
--header 'Content-Length: ' \
--data '{
    "ChainId": "chain1",
    "Addr": "59.110.154.31:12301",
    "OrgId": "wx-org1.chainmaker.org",
    "Tls": false,
    "OrgCA": "",
    "UserCert": "-----BEGIN PUBLIC KEY-----\nMIIBCgKCAQEA2sF68pHamotG71kavLhXUd9Hrm0DI5xAW4bSsqD+7aAIV4nnshm4\nmeoBSr6jwm6etz2PcR0avqcINaKjqjJWBsqNVi9Em5SzChRb+mRTE0ZPDmYsmR3z\nhEBexvaFXtjNQ0Ki45tHTIrrfN8Q+p4Z08WuS+VOW3X0FipY5BIuG3ikV8C1rhuh\njHivFaKPpoAvZizG7GFadBImFuefl3Jm0mzO8u/e8q1TMgGBpeM1EJwZYoxqmm1w\nLUOYw+sxuW/bbuO8dsejVPA/j8p1MYuZ3qSLBfRmc2FAa3AZRGu2vkrSfIzHDDP4\nJPM1Zh6t3GlIMgPncNl+e5iwaph6Nj4vhwIDAQAB\n-----END PUBLIC KEY-----\n",
    "UserKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEpgIBAAKCAQEA2sF68pHamotG71kavLhXUd9Hrm0DI5xAW4bSsqD+7aAIV4nn\nshm4meoBSr6jwm6etz2PcR0avqcINaKjqjJWBsqNVi9Em5SzChRb+mRTE0ZPDmYs\nmR3zhEBexvaFXtjNQ0Ki45tHTIrrfN8Q+p4Z08WuS+VOW3X0FipY5BIuG3ikV8C1\nrhuhjHivFaKPpoAvZizG7GFadBImFuefl3Jm0mzO8u/e8q1TMgGBpeM1EJwZYoxq\nmm1wLUOYw+sxuW/bbuO8dsejVPA/j8p1MYuZ3qSLBfRmc2FAa3AZRGu2vkrSfIzH\nDDP4JPM1Zh6t3GlIMgPncNl+e5iwaph6Nj4vhwIDAQABAoIBAQCZPVH4HI4rFofB\nYQTm0Kdyldur53d8eZdnxkFQmpEaOrG9SMCCtZvoTdFL39HtgPoz2K7kCQRUK8QH\ndn/52LsElN1/UytXZUoqNGreM2sypFz69D4noKCWs1TxQX3aHDtl84cRtBO1Hdeq\nqMRHG3tyKxdW2TITxcQPxuhwFAAygvubag6VmetrR2lm5pxEAz1M0OK+0Cssd3Hg\nmpnoiyr0UJ47uM4wTElduWABI3aEw0gBAwqFRukWJmwCszsaz4i/AtDjRqa068/a\nb27vyGMxL4X6Quev4ezcDicE96LWSCZlNGAH7aiJiXA2+WOU9KJFqtQp17tLi8PR\nLIrbCm85AoGBAPbxe6W/fLI+PdCuSTZ62M29zYXUgYnp/HrDmECX7LdMYG+TU9ys\nUhz0gdumkHudXgBa1rWT++GSMlXfjTSzmsmmU+SQ3yYjq329NVtbWBddJZAmR2pd\nQbjMPpg4czoesExmEd9z26qKCnt45iZtPo51KfyU8JF8aKUTPEPxEdktAoGBAOLH\nWTtFyqFSFYbCk41iDvg+dhux7gXg1LWobzP6AFUbjjZi2sUi4hS1zsEtv5X6d7w0\nzJEYeve9b8REE5dVhkS1UhkeC/zOqp03/ZB1hLYVPBeK3JQKVk6D/gvJ6pSrL4Ap\n8rQXVxRQSx7dl8HSO7tY+XgBwabHdsEzJWLaybQDAoGBALxtINMlXOnJEnPkORsn\n+7xpwqQGtd1dPHkUPF21TzvCPKeGfGwa1QEhFOFcpEyelHai2chtpbnGS0A5N07q\naQbLMqJqZMt+VkG4mTkfZwVU3u+yNbYUeKygtHaERHApsI5rJ+IgTpI/iKYUZ1EU\n9LHQ9vuzTilFC7hCCC8ziFH1AoGBANmiEkJN0g5LJhlztgLi7hbSaqpdcV32zGuh\nP0cUTyleDnanG+hAd9MEP20oqEoYWrwlt4QviCMki5RA+MQs8XQSxr0QFtUAyL+k\nshTmkvvjGQ5G1zTDTtx+01kg55zRQ/6tQxwNoiX+gHkYk8EQLv62foLqvJt/pLn4\niZJ7AUNdAoGBAO6Vd3MFrwrOWkAJinVTPRM6unj+w870DY0nqGBdQ5stjAYxzjnG\nsyx6mxCGop9eVZlNSfrkF9pCGtcJZDqk4X5DbbElVRLfBp/rnG2YANAxzTs1WnHH\nTBH3pBNobDvfI4TMsSDmMwKNmZ//9CdX4wVMNBE0sOhmWO8MwceBwvqG\n-----END RSA PRIVATE KEY-----\n",
    "TLSHostName": ""
}'

explorer-MySQL

部署环境新建数据库工作目录 {WORKDIR}/chainmaker-explorer-mysql/docker

目录下拷贝 docker-compose.yml，注释前后端服务，修改为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
version: "3.9"

services:
  cm_explorer_db:
    image: mysql:5.7
    ports:
      - "3306:3306"
    volumes:
      - explorer_db_data:/home/docker/volumes/mysql3306
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: Baec&chainmaker
      MYSQL_USER: chainmaker@yqxc
      MYSQL_PASSWORD: Baec&chainmaker@yqxc
      MYSQL_DATABASE: chainmaker_explorer_dev
    command: [ 'mysqld', '--character-set-server=utf8mb4', '--collation-server=utf8mb4_unicode_ci' ]

#  cm_explorer_server:
#    image: chainmakerofficial/explorer-backend:v2.2.0
#    depends_on:
#      - cm_explorer_db
#    ports:
#      - "9997:9997"
#    restart: always
#
#  cm_explorer_web:
#      depends_on:
#        - cm_explorer_server
#      image: chainmakerofficial/explorer-web:v2.2.1
#      ports:
#        - "80:8080"
#      restart: always

volumes:
  explorer_db_data: { }

启动命令：

1
2
cd {WORKDIR}/chainmaker-explorer-mysql/docker
docker-compose up -d

explorer-web

  • 注释：新增订阅+修改订阅+取消订阅

本地调试：README.md文件查看本地启动命令，修改 src/utils/apis/request.ts 连接到实际后端，修改完成后需把配置切换回去。

1
2
3
4
5
6
7
8
9
// // const BASEURL = 'http://192.168.1.108:8888/chainmaker';
// const instance = axios.create({
//   baseURL: '/chainmaker/', // process.env.NODE_ENV === 'production' ? BASEURL : '/chainmaker',
// });
// 后端URL
const BASEURL = 'http://59.110.154.31:9997/chainmaker';
const instance = axios.create({
    baseURL: process.env.NODE_ENV === 'production' ? '/chainmaker' : BASEURL,
});

注释新增订阅 注释修改订阅 注释取消订阅：直接关键词搜索位置，注释，并根据提示注释无用的组件和常量。

拷贝整个项目到服务器环境（不拷贝node_modules），docker打包，参考Makefile文件，注意镜像版本version与docker-compose一致。

解决RUN npm install卡死：安装与build.Dockerfile相同版本的Node，本机或服务器环境执行npm install，生成node_modules文件夹（需要拷贝node_modules），此文件夹将应用到docker的build环境。

Ubuntu安装指定版本的Node（小版本号）

1
2
3
4
5
6
7
8
9
10
11
// Download
cd ~/install_tools_src 
wget https://nodejs.org/dist/v14.18.1/node-v14.18.1-linux-x64.tar.xz
// 服务器下载卡死，可以通过本地浏览器下载，然后ftp传输到服务器

// Install 
cd /usr/local 
tar --strip-components 1 -xJf ~/install_tools_src/node-v14.18.1-linux-x64.tar.xz

// Verify 
node -v npm version

服务器环境RUN npm install运行时间超长：在本地结合WebStorm构建项目，build出输出目录，修改build.Dockerfile，注释install+build过程，直接使用nginx和build目录构建镜像。

项目目录下新建docker目录，拷贝explorer-backend的docker-compose.yml文件，修改为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
version: "3.9"

services:
  #  cm_explorer_db:
  #    image: mysql:5.7
  #    ports:
  #      - "3306:3306"
  #    volumes:
  #      - explorer_db_data:/home/docker/volumes/mysql3306
  #    restart: always
  #    environment:
  #      MYSQL_ROOT_PASSWORD: Baec&chainmaker
  #      MYSQL_USER: chainmaker@yqxc
  #      MYSQL_PASSWORD: Baec&chainmaker@yqxc
  #      MYSQL_DATABASE: chainmaker_explorer_dev
  #    command: [ 'mysqld', '--character-set-server=utf8mb4', '--collation-server=utf8mb4_unicode_ci' ]
  
  #  cm_explorer_server:
  #    image: chainmakerofficial/explorer-backend:v2.2.0
  #    #    depends_on:
  #    #      - cm_explorer_db
  #    ports:
  #      - "9997:9997"
  #    restart: always

  cm_explorer_web:
    #      depends_on:
    #        - cm_explorer_server
    image: chainmakerofficial/explorer-web:v2.2.1
    ports:
      - "80:8080"
    restart: always

volumes:
  explorer_db_data: { }

docker启动cm_explorer_web服务。

修正区块链浏览器数据

部署完成后，区块链浏览器展示的节点数只有3个，本应该有4个，另外一个连接数据库，手动增加。

1
2
3
4
5
6
7
# node_id 去 crypto-config/wx-org1.chainmaker.org/node/consensus1/consensus1.nodeid 获取
# address 只有端口不一样，端口分别为：11301,11302,11303,11304
INSERT INTO chainmaker_explorer_dev.cmb_node (create_at, update_at, node_id, node_name, org_id, role, address, block_height, status) VALUES ('2022-10-26 17:13:22', '2022-10-26 17:13:22', 'QmdKfBdAbV3qbBknrmrurRTa5F4da2MjmTqhzeWURdE2H8', '', '', '', '/ip4/127.0.0.1/tcp/11301', 0, '');

INSERT INTO chainmaker_explorer_dev.cmb_node2chain (create_at, update_at, node_id, chain_id) VALUES ('2022-10-26 17:13:22', '2022-10-26 17:13:22', 'QmdKfBdAbV3qbBknrmrurRTa5F4da2MjmTqhzeWURdE2H8', 'chain1');

# cmb_node 和 cmb_node2chain 的 node_id 需要一一对应

查询 node_id

组织与节点的关系也不对，手动绑定关系

区块链浏览器二次启动

原本在区块链浏览器可视化的Web界面重新订阅（修改订阅）即可实现重新连接，修改订阅的参数与创建订阅时的参数一致。

但现在区块链Web界面取消了那个按钮，所以需要调用后端接口API实现重新订阅。

通过curl、ApiFox等执行下面的请求即可实现重新订阅链，请求参数需要和创建订阅时的一致，可到数据库复制出数据，证书中的回车使用\n替换。

1
2
3
4
5
6
7
8
9
10
11
12
13
curl --location --request POST 'http://59.110.154.31:9997/chainmaker/?cmb=ModifySubscribe' \
--header 'User-Agent: apifox/1.0.0 (https://www.apifox.cn)' \
--header 'Content-Type: application/json' \
--data '{
    "ChainId": "chain1",
    "Addr": "172.176.198.158:12301",
    "OrgId": "wx-org1.chainmaker.org",
    "Tls": false,
    "OrgCA": "",
    "UserCert": "-----BEGIN PUBLIC KEY-----\nMIIBCgKCAQEA2sF68pHamotG71kavLhXUd9Hrm0DI5xAW4bSsqD+7aAIV4nnshm4\nmeoBSr6jwm6etz2PcR0avqcINaKjqjJWBsqNVi9Em5SzChRb+mRTE0ZPDmYsmR3z\nhEBexvaFXtjNQ0Ki45tHTIrrfN8Q+p4Z08WuS+VOW3X0FipY5BIuG3ikV8C1rhuh\njHivFaKPpoAvZizG7GFadBImFuefl3Jm0mzO8u/e8q1TMgGBpeM1EJwZYoxqmm1w\nLUOYw+sxuW/bbuO8dsejVPA/j8p1MYuZ3qSLBfRmc2FAa3AZRGu2vkrSfIzHDDP4\nJPM1Zh6t3GlIMgPncNl+e5iwaph6Nj4vhwIDAQAB\n-----END PUBLIC KEY-----\n",
    "UserKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEpgIBAAKCAQEA2sF68pHamotG71kavLhXUd9Hrm0DI5xAW4bSsqD+7aAIV4nn\nshm4meoBSr6jwm6etz2PcR0avqcINaKjqjJWBsqNVi9Em5SzChRb+mRTE0ZPDmYs\nmR3zhEBexvaFXtjNQ0Ki45tHTIrrfN8Q+p4Z08WuS+VOW3X0FipY5BIuG3ikV8C1\nrhuhjHivFaKPpoAvZizG7GFadBImFuefl3Jm0mzO8u/e8q1TMgGBpeM1EJwZYoxq\nmm1wLUOYw+sxuW/bbuO8dsejVPA/j8p1MYuZ3qSLBfRmc2FAa3AZRGu2vkrSfIzH\nDDP4JPM1Zh6t3GlIMgPncNl+e5iwaph6Nj4vhwIDAQABAoIBAQCZPVH4HI4rFofB\nYQTm0Kdyldur53d8eZdnxkFQmpEaOrG9SMCCtZvoTdFL39HtgPoz2K7kCQRUK8QH\ndn/52LsElN1/UytXZUoqNGreM2sypFz69D4noKCWs1TxQX3aHDtl84cRtBO1Hdeq\nqMRHG3tyKxdW2TITxcQPxuhwFAAygvubag6VmetrR2lm5pxEAz1M0OK+0Cssd3Hg\nmpnoiyr0UJ47uM4wTElduWABI3aEw0gBAwqFRukWJmwCszsaz4i/AtDjRqa068/a\nb27vyGMxL4X6Quev4ezcDicE96LWSCZlNGAH7aiJiXA2+WOU9KJFqtQp17tLi8PR\nLIrbCm85AoGBAPbxe6W/fLI+PdCuSTZ62M29zYXUgYnp/HrDmECX7LdMYG+TU9ys\nUhz0gdumkHudXgBa1rWT++GSMlXfjTSzmsmmU+SQ3yYjq329NVtbWBddJZAmR2pd\nQbjMPpg4czoesExmEd9z26qKCnt45iZtPo51KfyU8JF8aKUTPEPxEdktAoGBAOLH\nWTtFyqFSFYbCk41iDvg+dhux7gXg1LWobzP6AFUbjjZi2sUi4hS1zsEtv5X6d7w0\nzJEYeve9b8REE5dVhkS1UhkeC/zOqp03/ZB1hLYVPBeK3JQKVk6D/gvJ6pSrL4Ap\n8rQXVxRQSx7dl8HSO7tY+XgBwabHdsEzJWLaybQDAoGBALxtINMlXOnJEnPkORsn\n+7xpwqQGtd1dPHkUPF21TzvCPKeGfGwa1QEhFOFcpEyelHai2chtpbnGS0A5N07q\naQbLMqJqZMt+VkG4mTkfZwVU3u+yNbYUeKygtHaERHApsI5rJ+IgTpI/iKYUZ1EU\n9LHQ9vuzTilFC7hCCC8ziFH1AoGBANmiEkJN0g5LJhlztgLi7hbSaqpdcV32zGuh\nP0cUTyleDnanG+hAd9MEP20oqEoYWrwlt4QviCMki5RA+MQs8XQSxr0QFtUAyL+k\nshTmkvvjGQ5G1zTDTtx+01kg55zRQ/6tQxwNoiX+gHkYk8EQLv62foLqvJt/pLn4\niZJ7AUNdAoGBAO6Vd3MFrwrOWkAJinVTPRM6unj+w870DY0nqGBdQ5stjAYxzjnG\nsyx6mxCGop9eVZlNSfrkF9pCGtcJZDqk4X5DbbElVRLfBp/rnG2YANAxzTs1WnHH\nTBH3pBNobDvfI4TMsSDmMwKNmZ//9CdX4wVMNBE0sOhmWO8MwceBwvqG\n-----END RSA PRIVATE KEY-----\n",
    "TLSHostName": ""
}'

区块链浏览器发行转移数据缺失

本地调试发现，区块链浏览器发行、转移等数据不记录到数据库是因为数据库数据表cmb_contract_event的字段event_data长度不足导致的，而发行、转移行为在链上是成功的，修改字段event_data的长度即可，最大可设置到longtext。修正后，区块链浏览器数据正常。

链性能优化

chainmaker.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
txpool:
 # 普通交易池上限
 max_txpool_size: 100000
monitor:
 # Monitor service switch, default is false.
 # 服务质量监控分析工具
 enabled: true
# PProf Settings
pprof:
 # 性能剖析
 # If pprof is enabled or not
 enabled: true
storage:
 write_block_type: 1  # 0普通写模式，1快速写模式
 blockdb_config:
   provider: leveldb
   leveldb_config:
     store_path: ../data/wx-org1.chainmaker.org/block
     no_sync: true
     compaction_l0_trigger: 16
     write_l0_slowdown_trigger: 20
     write_l0_pause_trigger: 24
     write_buffer_size: 8
     compaction_table_size: 8
     compaction_total_size: 40
 
 statedb_config:
   provider: leveldb
   leveldb_config:
     store_path: ../data/wx-org1.chainmaker.org/state
     no_sync: true
     compaction_l0_trigger: 16
     write_l0_slowdown_trigger: 20
     write_l0_pause_trigger: 24
     write_buffer_size: 8
     compaction_table_size: 8
     compaction_total_size: 40
 
 historydb_config:
   provider: leveldb
   disable_contract_history: true
   disable_account_history: true
   leveldb_config:
     store_path: ../data/wx-org1.chainmaker.org/history
     no_sync: true
     compaction_l0_trigger: 16
     write_l0_slowdown_trigger: 20
     write_l0_pause_trigger: 24
     write_buffer_size: 8
     compaction_table_size: 8
     compaction_total_size: 40
 
 resultdb_config:
   provider: leveldb
   leveldb_config:
     store_path: ../data/wx-org1.chainmaker.org/result
     no_sync: true
     compaction_l0_trigger: 16
     write_l0_slowdown_trigger: 20
     write_l0_pause_trigger: 24
     write_buffer_size: 8
     compaction_table_size: 8
     compaction_total_size: 40

bc.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Block proposing related settings
block:
 # Verify the transaction timestamp or not
 # 是否需要开启交易时间戳校验
 tx_timestamp_verify: true

 # Transaction timeout, in second.
 # if abs(now - tx_timestamp) > tx_timeout, the transaction is invalid.
 # 交易时间戳的过期时间(秒)
 tx_timeout: 600

 # Max transaction count in a block.
 # 区块中最大交易数
 block_tx_capacity: 1000

 # Max block size, in MB
 # 区块最大限制，单位MB
 block_size: 100

 # The interval of block proposing attempts
 # 出块间隔，单位:ms
 block_interval: 200

其他问题

  1. 长安链后期大量数据处理方式，是继续增加挂载数据盘，还是冷热切割
    建议暂时不处理，长安链后期会进行冷热数据切割分离，到时候直接升级即可。

  2. 长安链浏览器数据库后期大量数据如何处理，分库分表吗？还是官方浏览器源码自带了某种解决策略？
    长安链浏览器数据库暂时没有解决该问题，需要自己进行优化，例如主从复制、读写分离、分表分区。

  3. 长安链浏览器官方源码部署，怎么增加安全性
    由于目前联盟链的区块链浏览器偏向管理者查看，一般对IP有限制，所以长安链浏览器并未做太多安全性限制，如果后期需要，可以考虑使用高防CDN等技术。

  4. 可以看下官方SDK下JAVA的方法名计算和python的方法名计算结果不一致，有一个发起上链一直失败，如计算：safeTransferFrom
    Java SDK在计算safeTransferFrom时存在bug，可以先提issue，使用Python的SDK。

  5. SDK使用中建议同时连接4个节点操作，还是连接某一个节点即可
    为了避免单点故障，提升性能，交易建议分别往多个节点发。但是需要考虑现实情况，是不是可以连接到别的组织的节点。

  6. ERC1155合约建议使用什么身份模式部署？
    合约与身份模式无关，我们的方案建议使用证书模式（PermissionedWithCert），可以实现完整的权限设置和保护。一般来说开放联盟链才会使用Public模式。

  7. ERC1155合约环境下，密钥对算法推荐哪个？RSA，ecc，sm？
    实测性能ECC>SM（gmssl）>SM（tencentsm）>RSA>SM（tjfoc），ECC和SM（gmssl）的整链性能大概差距10%，如果希望拥抱政策，建议使用后者，否则可以使用前者。

  8. Django部署生产应该注意的地方
    使用Conda虚拟环境、UWSGI-Web服务、ini配置文件启动、虚拟环境安装依赖、调大操作系统通信参数、开启多线程、日志切割、基本脚本（开启、关闭、查看状态）

  9. Django部署生产性能优化方式
    操作系统优化、listen最大值优化、多线程优化、开启master
    IO密集应用，设置log-master

  10. 在链的从0到1到投入生产的过程中，有什么需要注意的问题，以及有什么建议
    充分的测试，最好需要参考官网cmc工具进行压力测试（例如压72小时），如：
    nohup ./cmc parallel invoke –loopNum=3600000 –printTime=60 –threadNum=300 –timeout=360000 –sleepTime=100 –climbTime=5 –showKey=false –contract-name=dockerFact –method=invoke_contract –pairs=”” –pairs-file=”./testdata/save_go.json” –hosts=”127.0.0.1:12301” –auth-type=3 –hash-algorithm=SHA256 –user-keys=./testdata/crypto-config/node1/user/client1/client1.key –admin-sign-keys=./testdata/crypto-config/node1/admin/admin1/admin1.key &
    代码提交建议使用流水线测试
    资源监控，需要安装Prometheus，实时监控节点状态
    建议开启pprof
    建议启用服务器资源占用报警，及时抓取pprof/trace查看资源消耗情况
    条件允许，建议存储分盘读写，提升效率
    建议上线从内测开始，一段时间稳定后转正式上线

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

徘徊在原子与字节的边缘<br><br>将更好的自己呈现给世界<br><br><br><br>修心至要，事上磨练<br><br>一蓑衣，一壶酒，一曲长歌，一剑天涯<br><br>见自己，见天地，见众生<br><br>