HyperledgerFabric资产案例链码实例

最新推荐文章于 2022-07-26 21:40:12 发布
最新推荐文章于 2022-07-26 21:40:12 发布
阅读量326 收藏
点赞数
分类专栏： # Fabric 文章标签： 区块链 分布式账本
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shn111/article/details/124486084
版权

案例分析

  • 功能
    • 用户开户和销户
    • 资产登记，资产上链，与具体的用户绑定
    • 资产转让，资产所有权变更
    • 查询功能，用户查询，资产查询，资产变更的历史查询
  • 业务实体
    • 用户
      • 名字
      • 身份证（标识）
      • 资产列表
    • 资产
      • 名字
      • 标识
      • 特殊属性列表（车：排量、品牌、座位）
  • 资产变更记录
    • 资产标识
    • 资产的原始拥有者
    • 资产变更后的拥有者
  • 交互方法
    • 用户开户
      • 参数：名字、标识
    • 用户销户
      • 参数：标识
    • 资产登记
      • 参数：名字、标识、特殊属性列表、拥有者
    • 资产转让
      • 参数：拥有者、资产标识、受让者
    • 用户查询
      • 参数：用户标识；返回值：用户实体
    • 资产查询
      • 参数：资产标识；返回值：资产实体
    • 资产的变更历史查询
      • 参数：资产标识；返回值：资产的变更记录列表

案例测试

  • 创建通道的创世交易（channel名字不能有大写）
    configtxgen -profile TwoOrgsChannel -outputCreateChannelTx ./config/assetschannel.tx -channelID assetschannel
  • 启动网络
    docker-compose up -d
  • 交互执行
    docker exec -it cli bash
  • 创建通道
    peer channel create -o orderer.example.com:7050 -c assetschannel -f /etc/hyperledger/config/assetschannel.tx
  • 加入通道(一个peer可以加入多个通道)
    peer channel join -b assetschannel.block
  • 安装链码
    peer chaincode install -n assets -v 1.0.0 -l golang -p github.com/chaincode/assetsExchange
  • 实例化链码
    peer chaincode instantiate -o orderer.example.com:7050 -C assetschannel -n assets -v 1.0.0 -l golang -c'{"Args":["init"]}'

测试方法

  • 用户开户
    peer chaincode invoke -C assetschannel -n assets -c '{"Args":["userRegister","user1","user1"]}'
  • 用户查询
    peer chaincode query -C assetschannel -n assets -c '{"Args":["queryUser","user1"]}'
    在这里插入图片描述
  • 资产登记
    peer chaincode invoke -C assetschannel -n assets -c '{"Args":["assetEnroll","asset1","asset1","metadate","user1"]}'
  • 资产查询
    peer chaincode query -C assetschannel -n assets -c '{"Args":["queryAsset","asset1"]}'
    在这里插入图片描述再查询用户，可以看到用户资产已经改变
    peer chaincode query -C assetschannel -n assets -c '{"Args":["queryUser","user1"]}'- 在这里插入图片描述
  • 资产转让
    新建用户user2
    peer chaincode invoke -C assetschannel -n assets -c '{"Args":["userRegister","user2","user2"]}'
    资产转让，user1的资产asset1转给user2
    peer chaincode invoke -C assetschannel -n assets -c '{"Args":["assetExchange","user1","asset1","user2"]}'
  • 查询资产变更历史
    peer chaincode query -C assetschannel -n assets -c '{"Args":["queryAssetHistory","asset1"]}'
  • 删除用户，用户的资产会被同时删除
    peer chaincode invoke -C assetschannel -n assets -c '{"Args":["userDestroy","user2"]}'

案例代码

package main

import (
	"encoding/json"
	"fmt"
	"github.com/hyperledger/fabric/core/chaincode/shim"
	pb "github.com/hyperledger/fabric/protos/peer"
)

//定义链码
type AssetsExchangeCC struct {
}

//资产默认的原始拥有者
const (
	originOwner = "originOwnerPlaceholder"
)

//资产
type Asset struct {
	Name     string `json:"name"`
	Id       string `json:"id"`
	Metadata string `json:"metadata"`
}

//用户
type User struct {
	Name   string   `json:"name"`
	Id     string   `json:"id"`
	Assets []string `json:"assets"`
}

//资产变更记录
type AssetHistory struct {
	//资产标识
	AssetId string `json:"asset_id"`
	//资产的原始拥有者
	OriginOwnerId string `json:"origin_owner_id"`
	//变更后的拥有者
	CurrentOwnerId string `json:"current_owner_id"`
}

//链码的初始化
func (c *AssetsExchangeCC) Init(stub shim.ChaincodeStubInterface) pb.Response {
	return shim.Success(nil)
}

//链码交互
func (c *AssetsExchangeCC) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	//得到方法名
	funcName, args := stub.GetFunctionAndParameters()
	//根据不同方法去判断
	switch funcName {
	case "userRegister":
		//用户开户
		return userRegister(stub, args)
	case "userDestroy":
		//用户销户
		return userDestroy(stub, args)
	case "assetEnroll":
		//资产登记
		return assetEnroll(stub, args)
	case "assetExchange":
		//资产转让
		return assetExchange(stub, args)
	case "queryUser":
		//用户查询
		return queryUser(stub, args)
	case "queryAsset":
		//资产查询
		return queryAsset(stub, args)
	case "queryAssetHistory":
		//资产变更历史查询
		return queryAssetHistory(stub, args)
	default:
		return shim.Error(fmt.Sprintf("不支持的方法：%s", funcName))
	}
}

//用户开户
func userRegister(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	//判断个数必须为2个
	if len(args) != 2 {
		return shim.Error("参数个数错误")
	}
	//判断传过来的参数是a否为空
	name := args[0]
	id := args[1]
	if name == "" || id == "" {
		return shim.Error("无效的参数")
	}
	//判断用户是否存在，若存在，则报错
	if userBytes, err := stub.GetState(constructUserKey(id)); err == nil && len(userBytes) != 0 {
		return shim.Error("用户已存在")
	}

	//写入世界状态，传过来的是用户的名字和id，绑定User结构体 make([]string,0)
	user := &User{
		Name:   name,
		Id:     id,
		Assets: make([]string, 0),
	}
	//序列化
	userBytes, err := json.Marshal(user)
	if err != nil {
		return shim.Error(fmt.Sprintf("序列化与用户失败 %s", err))
	}

	//将对象状态写入数据库
	if err := stub.PutState(constructUserKey(id), userBytes); err != nil {
		return shim.Error(fmt.Sprintf("存入用户失败 %s", err))
	}
	//返回成功
	return shim.Success(nil)
}
func constructUserKey(userId string) string {
	return fmt.Sprintf("user_%s", userId)
}

//用户销户
func userDestroy(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	//参数个数1个
	if len(args) != 1 {
		return shim.Error("参数个数不对")
	}
	//校验参数正确性
	id := args[0]
	if id == "" {
		return shim.Error("无效的参数")
	}
	//判断用户是否存在
	userBytes, err := stub.GetState(constructUserKey(id))
	if err != nil && len(userBytes) == 0 {
		return shim.Error("找不到用户")
	}

	//写入状态
	if err := stub.DelState(constructUserKey(id)); err != nil {
		return shim.Error(fmt.Sprintf("删除用户失败 %s", err))
	}

	//删除用户名下的资产
	user := new(User)
	if err := json.Unmarshal(userBytes, user); err != nil {
		return shim.Error(fmt.Sprintf("反序列化失败 %s", err))
	}
	for _, assetid := range user.Assets {
		if err := stub.DelState(constructAssetKey(assetid)); err != nil {
			return shim.Error(fmt.Sprintf("删除资产失败 %s", err))
		}
	}
	return shim.Success(nil)
}

//使用组合键来区分
//所有的资产，用asset开头
func constructAssetKey(assetId string) string {
	return fmt.Sprintf("asset_%s", assetId)
}

//资产登记
func assetEnroll(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	if len(args) != 4 {
		return shim.Error("参数个数不对")
	}
	//验证正确性
	assetName := args[0]
	assetId := args[1]
	metadata := args[2]
	ownerId := args[3]
	//metadata可以为空
	if assetName == "" || assetId == "" || ownerId == "" {
		return shim.Error("无效的参数")
	}
	//验证拥有者是否存在,拥有者必须存在
	userBytes, err := stub.GetState(constructUserKey(ownerId))
	if err != nil || len(userBytes) == 0 {
		return shim.Error("找不到用户")
	}
	//验证资产是否存在,资产必须不存在
	if assetBytes, err := stub.GetState(constructAssetKey(assetId)); err == nil && len(assetBytes) != 0 {
		return shim.Error("资产已经存在")
	}

	//写入状态
	asset := &Asset{
		Name:     assetName,
		Id:       assetId,
		Metadata: metadata,
	}
	//序列化
	assetBytes, err := json.Marshal(asset)
	if err != nil {
		return shim.Error(fmt.Sprintf("序列化失败 %s", err))
	}
	//保存资产
	if err := stub.PutState(constructAssetKey(assetId), assetBytes); err != nil {
		return shim.Error(fmt.Sprintf("保存失败 %s", err))
	}

	//拥有者
	user := new(User)
	if err := json.Unmarshal(userBytes, user); err != nil {
		return shim.Error(fmt.Sprintf("反序列化失败 %s", err))
	}

	user.Assets = append(user.Assets, assetId)
	if userBytes, err = json.Marshal(user); err != nil {
		return shim.Error(fmt.Sprintf("序列化用户失败 %s", err))
	}
	//存储用户状态
	if err := stub.PutState(constructUserKey(user.Id), userBytes); err != nil {
		return shim.Error(fmt.Sprintf("保存用户失败 %s", err))
	}

	//资产历史变更
	history := &AssetHistory{
		AssetId:        assetId,
		OriginOwnerId:  originOwner,
		CurrentOwnerId: ownerId,
	}
	historyBytes, err := json.Marshal(history)
	if err != nil {
		return shim.Error(fmt.Sprintf("序列化失败 %s", err))
	}

	//使用fabric内置的组合键机制
	historyKey, err := stub.CreateCompositeKey("history", []string{
		assetId,
		originOwner,
		ownerId,
	})
	if err != nil {
		return shim.Error(fmt.Sprintf("创建key失败 %s", err))
	}

	//资产变更存储
	if err := stub.PutState(historyKey, historyBytes); err != nil {
		return shim.Error(fmt.Sprintf("保存变更历史失败 %s", err))
	}

	return shim.Success(nil)
}

//资产转让
func assetExchange(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	//参数个数为3个
	if len(args) != 3 {
		return shim.Error("参数个数不对")
	}
	//参数校验
	ownerId := args[0]
	assetId := args[1]
	currentOwnerId := args[2]
	if ownerId == "" || assetId == "" || currentOwnerId == "" {
		return shim.Error("无效的参数")
	}
	//验证当前和受让后的用户是否存在
	originOwnerBytes, err := stub.GetState(constructUserKey(ownerId))
	if err != nil || len(originOwnerBytes) == 0 {
		return shim.Error("用户找不到")
	}
	currentOwnerBytes, err := stub.GetState(constructUserKey(currentOwnerId))
	if err != nil || len(currentOwnerBytes) == 0 {
		return shim.Error("用户找不到")
	}
	//验证资产存在
	assetBytes, err := stub.GetState(constructAssetKey(assetId))
	if err != nil || len(assetBytes) == 0 {
		return shim.Error("资产找不到")
	}

	//校验原始拥有者确实拥有当前变更的资产
	originOwner := new(User)
	if err := json.Unmarshal(originOwnerBytes, originOwner); err != nil {
		return shim.Error(fmt.Sprintf("反序列化失败 %s", err))
	}

	//定义标记，标识资产是否存在
	aidexist := false
	for _, aid := range originOwner.Assets {
		if aid == assetId {
			//若找到该资产，则变更状态，结束循环
			aidexist = true
			break
		}
	}

	if !aidexist {
		return shim.Error("资产所有者不匹配")
	}

	//写入状态
	//1.将资产的原始拥有者资产id删除
	//2.新拥有者写入资产id,资产绑定
	//3.资产变更记录

	assetIds := make([]string, 0)
	for _, aid := range originOwner.Assets {
		if aid == assetId {
			//遍历到了要转让的资产
			continue
		}
		assetIds = append(assetIds, aid)
	}

	originOwner.Assets = assetIds
	//序列化
	originOwnerBytes, err = json.Marshal(originOwner)
	if err != nil {
		return shim.Error(fmt.Sprintf("序列化失败 %s", err))
	}

	//存储原始拥有者
	if err := stub.PutState(constructUserKey(ownerId), originOwnerBytes); err != nil {
		return shim.Error(fmt.Sprintf("存储用户失败 %s", err))
	}

	//当前拥有者
	currentOwner := new(User)
	if err := json.Unmarshal(currentOwnerBytes, currentOwner); err != nil {
		return shim.Error(fmt.Sprintf("反序列化失败 %s", err))
	}

	//绑定资产
	currentOwner.Assets = append(currentOwner.Assets, assetId)
	currentOwnerBytes, err = json.Marshal(currentOwner)
	if err != nil {
		return shim.Error(fmt.Sprintf("序列化失败 %s", err))
	}
	//存储
	if err := stub.PutState(constructUserKey(currentOwnerId), currentOwnerBytes); err != nil {
		return shim.Error("保存用户失败")
	}

	//插入资产变更记录
	history := &AssetHistory{
		AssetId:        assetId,
		OriginOwnerId:  ownerId,
		CurrentOwnerId: currentOwnerId,
	}

	historyBytes, err := json.Marshal(history)
	if err != nil {
		return shim.Error(fmt.Sprintf("序列化失败 %s", err))
	}
	historyKey, err := stub.CreateCompositeKey("history", []string{
		assetId,
		ownerId,
		currentOwnerId,
	})
	if err != nil {
		return shim.Error(fmt.Sprintf("创建key失败 %s", err))
	}
	//存储历史变更记录
	if err := stub.PutState(historyKey, historyBytes); err != nil {
		return shim.Error(fmt.Sprintf("保存失败 %s", err))
	}
	return shim.Success(nil)
}

//用户查询
func queryUser(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	//参数个数1个
	if len(args) != 1 {
		return shim.Error("参数个数不对")
	}

	//校验正确性
	ownerId := args[0]
	if ownerId == "" {
		return shim.Error("无效的参数")
	}

	userBytes, err := stub.GetState(constructUserKey(ownerId))
	if err != nil || len(userBytes) == 0 {
		return shim.Error("找不到用户")
	}
	return shim.Success(userBytes)
}

//资产查询
func queryAsset(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	//参数个数1个
	if len(args) != 1 {
		return shim.Error("参数个数不对")
	}

	//校验正确性
	assetId := args[0]
	if assetId == "" {
		return shim.Error("无效的参数")
	}

	assetBytes, err := stub.GetState(constructAssetKey(assetId))
	if err != nil || len(assetBytes) == 0 {
		return shim.Error("找不到资产")
	}
	return shim.Success(assetBytes)
}

//资产历史变更查询
func queryAssetHistory(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	//参数个数1个
	if len(args) != 1 && len(args) != 2 {
		return shim.Error("参数个数不对")
	}

	//校验参数的正确性
	assetId := args[0]
	if assetId == "" {
		return shim.Error("无效的参数")
	}

	//queryType：all
	//默认为all
	queryType := "all"
	if len(args) == 2 {
		//变为用户传的值
		queryType = args[1]
	}

	//参数校验
	if queryType != "all" && queryType != "exchange" && queryType != "enroll" {
		return shim.Error(fmt.Sprintf("未知的查询类型 %s", queryType))
	}

	//校验资产是否存在
	assetBytes, err := stub.GetState(constructAssetKey(assetId))
	if err != nil || len(assetBytes) == 0 {
		return shim.Error("资产找不到")
	}

	keys := make([]string, 0)
	keys = append(keys, assetId)
	switch queryType {
	case "enroll":
		//资产登记
		keys = append(keys, originOwner)
	case "exchange", "all":
	default:
		return shim.Error(fmt.Sprintf("不支持的类型 %s", queryType))
	}

	//组合键
	//得到迭代器
	result, err := stub.GetStateByPartialCompositeKey("history", keys)
	if err != nil {
		return shim.Error(fmt.Sprintf("查询历史错误 %s", err))
	}

	//关闭
	defer result.Close()

	histories := make([]*AssetHistory, 0)
	for result.HasNext() {
		historyVal, err := result.Next()
		if err != nil {
			return shim.Error(fmt.Sprintf("查询错误 %s", err))
		}

		history := new(AssetHistory)
		if err := json.Unmarshal(historyVal.GetValue(), history); err != nil {
			return shim.Error(fmt.Sprintf("反序列化失败 %s", err))
		}

		//过滤，不是资产转让的记录过滤
		if queryType == "exchange" && history.OriginOwnerId == originOwner {
			continue
		}
		histories = append(histories, history)
	}

	historiesBytes, err := json.Marshal(histories)
	if err != nil {
		return shim.Error(fmt.Sprintf("序列化失败 %s", err))
	}
	return shim.Success(historiesBytes)
}

func main() {
	err := shim.Start(new(AssetsExchangeCC))
	if err != nil {
		fmt.Println("启动链码失败")
	}
}
超级账本08：hyperledger fabric完整案例
欧阳桫的技术博客
12-05 2699
1.fabric开发流程 需求整理 合约编写 合约部署 合约交互 外部服务编写 2.需求分析 开发一个资产转让功能模块 平台功能 用户开户和销户 资产登记，解决资产上链和用户绑定资产 资产转让，资产所有权的变更 查询功能，用户查询、资产查询、资产变更历史查询 3.合约编写 assetsExchange.go 4.合约部署 关闭docker 生成通道的创世交易 查看...
超级账本07：hyperledger fabric链码案例
欧阳桫的技术博客
12-05 721
1.链码入门 hello.go 安装链码 实例化链码 调用链码 2.账户相关链码 payment.go 安装链码 实例化链码 查询账户 转账 查询账户 存款 查询账户 取钱 查询账户 3.贷款还款相关链码 Trace/* 安装链码 实例化链码 运行测试 贷款 还款 4.公民身份信息相关链码 citizens.go 安装链码 实例化链码 身份录.
超级账本hyperledger fabric第十三集：hyperledger fabric终极案例
super_lixiang的博客
11-12 1056
一.fabric开发流程： 让什么数据上链：所有节点备份数据耗费空间，视频等不要上链 如何交互：-c “Args”[“方法名”,参数] 编写合约 Init Invoke 拖到linux运行，基于配置好的网络去部署运行（安装和实例化） 合约交互 SDK调用（页面点击或输入信息） 二.需求分析： 1.开发转让资产 2.功能 用户开户和销户 资产登记，资产上链，与具体的用户...
区块链100讲：用一个案例说明Hyperledger Fabric网络构架
weixin_34307464的博客
07-04 251
无论是想专注于Composer开发的，还是自己搭建Fabric网络的，都绕不开Fabric构架这一关。（发现绕过方法的人，请于文末留言，顶礼膜拜~）。本文将通过一个网络组建的实践重点介绍Fabric网络。 1 Fabric网络概要 tx: transaction 交易，操作。 比如去超市买狗粮的时候，从自己的电子钱包转帐到咖啡店这个请求，可以看作是一个tx。 比如你收到快递，你通过快递公司的应...
IBM关于区块链的HyperLedger Fabric项目第八讲PPT：Fabric应用案例赏析
10-29
IBM开源技术社区关于区块链的HyperLedger Fabric项目系列讲堂的第八讲的PPT，讲课很详细，ppt做的很棒，其中一些图表都有借鉴意义。第九讲内容主要是Fabric应用案例
资产管理链码
09-06
可以实现查询、新增、转账、增加、删除、历史查询、证书验证等功能的链码
Fabric 编写案例 链码
lws24919的博客
07-21 843
链码案例编写/运行资产案例链码
boundaries.rar_4-方向链码_8方向边界_差分链码MATLAB_边界差分链码_边界链码
07-14
本资源"boundaries.rar_4-方向链码_8方向边界_差分链码MATLAB_边界差分链码_边界链码"主要涵盖了4方向链码和8方向链码的概念及其在MATLAB中的实现，同时也涉及到边界差分链码和频率向量生成等技术。 首先，4方向...
HyperledgerFabric关键技术与案例分析整理记录.pdf
07-10
Hyperledger Fabric是Linux基金会发起的开源区块链项目，其关键技术与案例分析涵盖了区块链领域的核心概念、设计原理和实际应用。以下是对这些知识点的详细说明： 1. **区块链基础**：区块链是一种分布式数据库，由...
4.3. 链码安装及实例化1
08-03
4.3. 链码安装及实例化1
Hyperledger Fabric在Ubuntu上的搭建和例子运行
03-12
Hyperledger Fabric在Ubuntu上的搭建和例子运行，window电脑可以搭建虚拟机啊安装Ubuntu
hyperledger fabric单机单节点快速部署实例
01-20
hyperledger fabric单机单节点网络,solo共识机制，包含Java chaincode，部署之后直接run.sh脚本
贸易物流行业Hyperledger Fabric区块链用例
mongo_node的专栏
01-25 1207
区块链是最热门的技术之一，风险资本家正在投入大量资金。最初的区块链概念得到了比特币（Satoshi Nakamoto和他的论文）的推广。不可变分布式分类帐的概念在fintech之外的许多用例中具有很大的前景。在我之前的文章中，我曾提到过我在大型零售商处参与的区块链供应链使用案例。另一个与供应链密切相关的领域是“跨境贸易”。这个重点是使用区块链进行跨境贸易，但是当与供应链使用案例（我之前已经写过）结...
Fabric中链码安装
weixin_41946008的博客
10-06 824
链码安装的代码如下： # peer chaincode install -n firstcode -v 1.0 -p github.com/chaincode/firstcode/go/ -n 代表链码的名称 -v 代表链码的版本 -p 代表链码安装的位置（ps：安装的位置是相对于$GOPATH/src/ 目录而言） 但是我们在执行命令时需要在链码安装的位置添加一个链码的文件 package main //WARNING - this chaincode's ID is hard-coded in
Hyperledger Fabric链码Chaincode开发模式官方Demo演示
qq_42676042的博客
07-26 2390
fabric chaincode 开发者模式
Hyperledger Fabric Chaincode开发详解（实例说明）
草根工厂——技术虐我千百遍，我依然待你如初恋
07-08 6054
导言 目前fabric开发主要分两大块，一是chaincode链上代码的开发，二是基于SDK的application开发； 本文主要是介绍fabric chaincode api，对api的功能和参数进行说明，同时针对每个主要api都给出了 使用例子。 目标： 熟悉fabric chaincode常用api的功能和使用方法； 熟悉fabric chaincode的开发流程以及能够编写cha...
Fabric 链码安装及实例化详解
热门推荐
huchenguang
09-04 1万+
声明：本文的分析是基于fabric 1.4.0版本，其它版本实现类似，具体可以参考本文。 N久前，在一次误操作后，链码调用失败，返回信息如下： Error: endorsement failure during invoke. response: status:500 message:"failed to execute transaction a8025cd90781b2d907749adcc5...
Hyperledger Fabric学习笔记——7.链码安装、实例化、执行
polarday的博客
04-29 2371
1.智能合约 执行环境：以太坊虚拟智能合约执行环境EVM，fabric执行环境是docker 链码 是应用层和区块链底层的中间点 每一个链码执行环境是一个独立的docker 使用GRPC协议与背书节点通信，只有背书节点才能运行智能合约 链码的生命周期 打包：智能合约的编写和编译 安装：将打包好的文件，上传到背书节点 实例化：实际安装，执行Init方法，只执行一次，构造函数 升级：升级和修复链码 交互：自己定义的方法的调用 链码的交互流程 系统链码（CC：chaincode）
超级账本hyperledger fabric第八集：链码案例
super_lixiang的博客
11-08 842
链码入门： 以下这两个文件不要删，后续会用到。 创建hello.go 编写hello.go，完成后，拖到linux对应目录 package main import ( "github.com/hyperledger/fabric/core/chaincode/shim" pb "github.com/hyperledger/fabric/protos/peer" "fmt" )...
fabric java sdk 获取实例化链码名称
最新发布
05-15
要获取实例化链码的名称，您需要使用 Fabric Java SDK 中的 `ChaincodeID` 类。可以使用以下代码获取实例化链码的名称： ```java // 创建 ChaincodeID 对象 ChaincodeID chaincodeID = ChaincodeID.newBuilder()....
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值