Hyperledger fabric 链码篇GO（四）

fabric中的链码也就是我们区块链所认知的智能合约，fabric中可由nodejs,java,go编写，本篇只针对GO语言编写链码。将详细介绍链码编写所必须的函数以及相关功能函数。

1、常识

链码的包名指定
```
// xxx.go
package main
```

必须要引入的包

import(
    "github.com/hyperledger/fabric/core/chaincode/shim"
    pb "github.com/hyperledger/fabric/protos/peer"
    //pb为别名的意思
)

链码的书写要求

//自定义结构体，类，基于这个类实现接口函数
type Test struct{
	//空着即可
}

链码API查询

//go语言的链码包shim
https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim

注意事项

要注意put写入的数据状态不会立刻得到获取，因为put只是执行链码的模拟交易，并不会真正将状态保存在账本中，必须经过orderer达成共识之后，将数据状态保存在区块中，然后保存在各peer节点的账本中

2、函数及链码基本结构

success

// Success ... status:200
//链码执行后返回成功信息
func Success(payload []byte) pb.Response {
	return pb.Response{
		Status:  OK,
		Payload: payload,
	}
}

error

// Error ...status:500
//链码执行后返回错误信息
func Error(msg string) pb.Response {
	return pb.Response{
		Status:  ERROR,
		Message: msg,
	}
}

2.1、基本结构

下面是编写一个链码的基本框架，由空结构体，Init函数和Invoke函数，主函数组成

package main
//引入必要的包
import (
	"fmt"
	"strconv"
	"github.com/hyperledger/fabric/core/chaincode/shim"
    //别名pb
	pb "github.com/hyperledger/fabric/protos/peer"
)
// 声明一个结构体，必备，为空
type SimpleChaincode struct {
}
//添加Init函数
func (t *SimpleChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
		//实现链码初始化或升级时的处理逻辑
       //编写时可灵活使用stub中的API
}
//添加Invoke函数
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	//实现链码运行中被调用或查询时的处理逻辑
    //编写时可灵活使用stub中的API
}
//主函数，需要调用shim.Start()方法启动链码
func main() {
	err := shim.Start(new(SimpleChaincode))
	if err != nil {
		fmt.Printf("Error starting Simple chaincode: %s", err)
	}
}

2.2、Init函数

Init方法是系统初始化方法，当执行命令peer chaincode instantiate实例化chaincode时会调用该方法，同时命令中-c选项后面内容为会作为参数传入Init方法中。

#shell 命令
$ peer chaincode instantiate -o orderer.example.com:7050  -C $CHANNEL_NAME -n mycc -v 1.0 -c \'{"Args":["init","a","100", "b", "100"]}\'

Args中共有5个参数，第一个为固定值，后面4个为参数，如果传入数据太多，可以采用json等数据格式

func (t *SimpleChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
		 _ ,args := stub.GetFunctionAndParameters()
    return shim.Success ([]byte("success init!!!"))
}

2.3、Invoke函数

Invoke方法的主要作用为写入数据，比如发起交易等，在执行命令 peer chaincode invoke 时系统会调用该方法，并把-c后的参数传入invoke方法中。

参数原理和init类似

3、账本操作API

ChaincodeStubInterface

3.1、参数解析API

含义：调用链码时需要给被调用的目标函数/方法传递参数，与参数解析相关的API 提供了获取这些参数（包括被调用的目标函数/方法名称）的方法

GetFunctionAndParameters

获取客户端传入的参数GetFunctionAndParameters()

//源码
func (s *ChaincodeStub) GetFunctionAndParameters() (function string, params []string) {
	allargs := s.GetStringArgs()
	function = ""
	params = []string{}
	if len(allargs) >= 1 {
        //返回时第一个为函数名，后面为其他参数
		function = allargs[0]
		params = allargs[1:]
	}
	return
}
//执行命令
peer chaincode invoke -o orderer.example.com:7050  -C $CHANNEL_NAME -n mycc -v 1.0 -c \'{"Args":["invoke","a", "b", "10"]}\' 
//示例代码
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    _ ,args := stub.GetFunctionAndParameters()
    //获取执行命令中的参数a,b,10
    var a_parm = args[0]
    var b_parm = args[1]
    var c_parm = args[2]
    return shim.Success ([]byte("success invoke!!!"))
}

3.2、账本数据状态操作API

含义：该类型API提供了对账本数据状态进行操作的方法，包括对状态数据的查询以及事务处理

GetState

GetState(key string) ([]byte, error) :根据指定的key查询相应的数据状态

func (s *ChaincodeStub) GetState(key string) ([]byte, error) {
	// Access public data by setting the collection to empty string
	collection := ""
	return s.handler.handleGetState(collection, key, s.ChannelID, s.TxID)
}
//示例代码
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    keyvalue, err := stub.GetState("user1")
    return shim.Success(keyvalue)
}

PutState

PutState(key string, value []byte) error：根据指定的key，将相应的value保存在分类账本中

func (s *ChaincodeStub) PutState(key string, value []byte) error {
	if key == "" {
		return errors.New("key must not be an empty string")
	}
	// Access public data by setting the collection to empty string
	collection := ""
	return s.handler.handlePutState(collection, key, value, s.ChannelID, s.TxID)
}
//示例代码
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    stub.PutState("user1",[]byte("putvalue"))
    return shim.Success([]byte("sucess invoke putstate"))
}

DelState

DelState(key string) error:根据指定的key将对应的数据状态删除

func (s *ChaincodeStub) DelState(key string) error {
	// Access public data by setting the collection to empty string
	collection := ""
	return s.handler.handleDelState(collection, key, s.ChannelID, s.TxID)
}
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    err :=stub.DelState("user1")
    return shim.Success("delete success")
}

GetStateByRange

GetStateByRange(startKey, endKey string) (StateQueryIteratorInterface, error):根据指定的开始key和结束key，查询范围内的所有数据状态，注意，结束key对应的数据状态不包含在返回的结果集中

func (s *ChaincodeStub) GetStateByRange(startKey, endKey string) (StateQueryIteratorInterface, error) {
	if startKey == "" {
		startKey = emptyKeySubstitute
	}
	if err := validateSimpleKeys(startKey, endKey); err != nil {
		return nil, err
	}
	collection := ""

	// ignore QueryResponseMetadata as it is not applicable for a range query without pagination
	iterator, _, err := s.handleGetStateByRange(collection, startKey, endKey, nil)
	return iterator, err
}
//示例代码
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    startKey = "startKey"
    endKey = "endKey"
    //根据范围查询，得到StateQueryIteratorInterface迭代器接口
    keyIter , err := stub.getStateByRange(startKey,endKey)
    //关闭迭代器接口
    defer keyIter.close()
    var keys []string
    for keyIter.HasNext(){            //如果有下一个节点
        //得到下一个键值对
        response, iterErr := keysIter.Next()
        if iterErr != nil{
        	return shim.Error(fmt.Sprintf("find an error  %s",iterErr))
        }
        keys = append(keys,response.Key)            //存储键值到数组中
    }
    //遍历key数组
    for key, value := range keys{
        fmt.Printf("key %d contains %s",key ,value)
    }
    //编码keys数组为json格式
    jsonKeys ,err = json.Marshal(keys)
    if err != nil{
        return shim.Error(fmt.Sprintf("data marshal json error:  %s",err))
    }
    //将编码之后的json字符串传递给客户端
    return shim.Success(jsonKeys)
}

GetHistoryForKey

GetHistoryForKey(key string) (HistoryQueryIteratorInterface, error):根据指定的key查询所有的历史记录信息

func (s *ChaincodeStub) GetHistoryForKey(key string) (HistoryQueryIteratorInterface, error) {
	response, err := s.handler.handleGetHistoryForKey(key, s.ChannelID, s.TxID)
	if err != nil {
		return nil, err
	}
	return &HistoryQueryIterator{CommonIterator: &CommonIterator{s.handler, s.ChannelID, s.TxID, response, 0}}, nil
}

//示例代码
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    
    keyIter , err := stub.GetHistoryForKey("user1")
    if err != nil{
            return shim.Error(fmt.Sprintf("GetHistoryForKey error:  %s",err))
        }
    //关闭迭代器接口
    defer keyIter.close()
    var keys []string
    for keyIter.HasNext(){            //如果有下一个节点
        //得到下一个键值对
        response, iterErr := keysIter.Next()
        if iterErr != nil{
        	return shim.Error(fmt.Sprintf("find an error  %s",iterErr))
        }
        //交易编号
        txid := response.TxId 
        //交易的值
        txvalue = response.Value
        //当前交易的状态
        txstatus = response.IsDelete	
        //交易发生的时间戳
        txtimestamp = response.Timestamp
        keys = append(keys,txid)            //存储键值到数组中
    }
    //编码keys数组为json格式
    jsonKeys ,err = json.Marshal(keys)
    if err != nil{
        return shim.Error(fmt.Sprintf("data marshal json error:  %s",err))
    }
    //将编码之后的json字符串传递给客户端
    return shim.Success(jsonKeys)
}

CreateCompositeKey

CreateCompositeKey(objectType string, attributes []string) (string, error)：创建一个复合键

func (s *ChaincodeStub) CreateCompositeKey(objectType string, attributes []string) (string, error) {
	return CreateCompositeKey(objectType, attributes)
}

func CreateCompositeKey(objectType string, attributes []string) (string, error) {
	if err := validateCompositeKeyAttribute(objectType); err != nil {
		return "", err
	}
	ck := compositeKeyNamespace + objectType + string(minUnicodeRuneValue)
	for _, att := range attributes {
		if err := validateCompositeKeyAttribute(att); err != nil {
			return "", err
		}
		ck += att + string(minUnicodeRuneValue)
	}
	return ck, nil
}

SplitCompositeKey

SplitCompositeKey(compositeKey string) (string, []string, error):对指定的复合键进行分割

func (s *ChaincodeStub) SplitCompositeKey(compositeKey string) (string, []string, error) {
	return splitCompositeKey(compositeKey)
}

func splitCompositeKey(compositeKey string) (string, []string, error) {
	componentIndex := 1
	components := []string{}
	for i := 1; i < len(compositeKey); i++ {
		if compositeKey[i] == minUnicodeRuneValue {
			components = append(components, compositeKey[componentIndex:i])
			componentIndex = i + 1
		}
	}
	return components[0], components[1:], nil
}

GetQueryResult

GetQueryResult(query string) (StateQueryIteratorInterface, error) :对状态数据库进行富查询，目前支持富查询的只有CouchDB

func (s *ChaincodeStub) GetQueryResult(query string) (StateQueryIteratorInterface, error) {
	// Access public data by setting the collection to empty string
	collection := ""
	// ignore QueryResponseMetadata as it is not applicable for a rich query without pagination
	iterator, _, err := s.handleGetQueryResult(collection, query, nil)

	return iterator, err
}

InvokeChaincode

InvokeChaincode(chaincodeName string, args [][]byte, channel string)：调用其他链码

//链码名，传递参数，通道名
func (s *ChaincodeStub) InvokeChaincode(chaincodeName string, args [][]byte, channel string) pb.Response {
	// Internally we handle chaincode name as a composite name
	if channel != "" {
		chaincodeName = chaincodeName + "/" + channel
	}
	return s.handler.handleInvokeChaincode(chaincodeName, args, s.ChannelID, s.TxID)
}
//示例代码
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    //设置参数，a向b转账11
    trans := [][]byte{[]byte("invoke"),[]byte("a"),[]byte("b"),[]byte("11")}
    //调用chaincode
    response := stub.InvokeChaincode("mycc",trans,"mychannel")
    //判断是否操作成功
    if  response.Status != shim.OK {
        errStr := fmt.Sprintf("Invoke failed ,error : %s ", response.Payload)
        return shim.Error(errStr)
    }
    return shim.Success([]byte"转账成功")
}

3.3、交易信息API

含义：获取提交的交易信息的相关API

GetTxID

GetTxID() string :返回交易提案中指定的交易ID

func (s *ChaincodeStub) GetTxID() string {
	return s.TxID
}

GetChannelID

GetChannelID() string：返回交易提案中指定通道的ID

func (s *ChaincodeStub) GetChannelID() string {
	return s.ChannelID
}

GetTxTimestamp

GetTxTimestamp() (*timestamp.Timestamp, error):返回交易创建的时间戳，这个时间戳时peer接收到交易的具体时间

func (s *ChaincodeStub) GetTxTimestamp() (*timestamp.Timestamp, error) {
	hdr := &common.Header{}
	if err := proto.Unmarshal(s.proposal.Header, hdr); err != nil {
		return nil, fmt.Errorf("error unmarshaling Header: %s", err)
	}

	chdr := &common.ChannelHeader{}
	if err := proto.Unmarshal(hdr.ChannelHeader, chdr); err != nil {
		return nil, fmt.Errorf("error unmarshaling ChannelHeader: %s", err)
	}

	return chdr.GetTimestamp(), nil
}

GetBinding

GetBinding() ([]byte, error)：返回交易的绑定信息，如一些临时性信息，以避免重复性攻击
```
func (s *ChaincodeStub) GetBinding() ([]byte, error) {
	return s.binding, nil
}
```

GetSignedProposal

GetSignedProposal() (*pb.SignedProposal, error):返回与交易提案相关的签名身份信息

func (s *ChaincodeStub) GetSignedProposal() (*pb.SignedProposal, error) {
	return s.signedProposal, nil
}

GetCreator

GetCreator() ([]byte, error) ：返回该交易提交者的身份信息

func (s *ChaincodeStub) GetCreator() ([]byte, error) {
	return s.creator, nil
}

GetTransient

GetTransient() (map[string][]byte, error):返回交易中不会被写至账本中的一些临时性信息
```
func (s *ChaincodeStub) GetTransient() (map[string][]byte, error) {
	return s.transient, nil
}
```

3.4、事件处理API

含义：与事件处理相关的API

SetEvent

SetEvent(name string, payload []byte) error:设置事件，包括事件名称和内容

// SetEvent documentation can be found in interfaces.go
func (s *ChaincodeStub) SetEvent(name string, payload []byte) error {
	if name == "" {
		return errors.New("event name can not be empty string")
	}
	s.chaincodeEvent = &pb.ChaincodeEvent{EventName: name, Payload: payload}
	return nil
}

3.5、对PrivateData操作的API

含义：hyperledger fabric在1.2.0版本中新增的对私有数据操作的相关API

//根据指定key,从指定的私有数据集中查询对应的私有数据
func (s *ChaincodeStub) GetPrivateData(collection string, key string) ([]byte, error)
//根据给定的部分组合键的集合，查询给定的私有状态
func (s *ChaincodeStub) GetPrivateDataByPartialCompositeKey(collection, objectType string, attributes []string) (StateQueryIteratorInterface, error)
//根据指定的开始key和结束key查询范围内的私有数据（不包括结束key）
func (s *ChaincodeStub) GetPrivateDataByRange(collection, startKey, endKey string) (StateQueryIteratorInterface, error)
//根据指定的查询字符串执行富查询
func (s *ChaincodeStub) GetPrivateDataQueryResult(collection, query string) (StateQueryIteratorInterface, error)
//将指定的key与value保存到私有数据集中
func (s *ChaincodeStub) PutPrivateData(collection string, key string, value []byte) error
//根据key删除相应数据
func (s *ChaincodeStub) DelPrivateData(collection string, key string) error

4、背书策略

背书的过程就是一笔交易被确认的过程，而背书策略就是用来指示相关的参与方如何对交易进行确认。背书策略的设置是通过部署链码实例化时instantiate命令中的-P参数来设置的

peer chaincode instantiate -o orderer.example.com:7050 --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n mycc -v 1.0 -c \'{"Args":["init","a", "100", "b","200"]}\' -P "AND (\'Org1MSP.member\',\'Org2MSP.member\')"

此命令表示需要组织1和组织2中任意一个用户共同来参与交易的确认并且同意，这样的交易才能生效并被记录到去区块链中

#也可以指定背书节点，使用peerAddresses来指定背书节点
peer chaincode invoke -o orderer.example.com:7050 --tls true --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n mycc --peerAddresses peer0.org1.example.com:7051 --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt --peerAddresses peer0.org2.example.com:9051 --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt -c \'{"Args":["invoke","a","b","10"]}\'

背书规则示例1

#需要组织中任意用户共同参与背书
"AND (\'Org1MSP.member\',  \'Org2MSP.member\')"

背书规则示例2

#只要组织中任意一个用户验证即可
"OR (\'Org1MSP.member\',  \'Org2MSP.member\')"

背书规则示例3

#两种方法让交易生效
#    1、组织1中有成员验证成功
#    2、组织2和组织3中有成员共同参与验证成功
"OR (\'Org1MSP.member\', AND (\'Org2MSP.member\',  \'Org3MSP.member\'))"

注意：背书规则只针对写入数据的操作进行校验，对于查询类的背书不操作

5、应用示例

设计了一个链码，实现了资产管理，转账交易的功能，主要实现了以下几个函数

init函数

初始化链码，设定账户名称及资产额度

invoke函数

实现函数的识别，并转到不同的函数功能

del函数

删除账户

find函数

查看账户额度

set函数

根据账户名称设定要存入的金额

get函数

根据账户名称设定要取出的金额

package main

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

type AssetChaincode struct {
	//empty
}

//Init function
func (t *AssetChaincode) Init(stub shim.ChaincodeStubInterface) peer.Response {
	_, args := stub.GetFunctionAndParameters()
	if len(args) != 4 {
		return shim.Error("Must four initialization parameters, representing name and money ,respectively")
	}
	var a = args[0]
	var acount = args[1]
	var b = args[2]
	var bcount = args[3]
	if len(a) < 2 {
		return shim.Error("the length of name must not less than 2")
	}
	if len(b) < 2 {
		return shim.Error("the length of name must not less than 2")
	}
	_, err := strconv.Atoi(acount)
	if err != nil {
		return shim.Error(a + " account is false")
	}
	_, err = strconv.Atoi(bcount)
	if err != nil {
		return shim.Error(b + " account is false")
	}

	err = stub.PutState(a, []byte(acount))
	if err != nil {
		return shim.Error(a + " Occuring error when saving the data")
	}
	err = stub.PutState(b, []byte(bcount))
	if err != nil {
		return shim.Error(b + " Occuring error when saving the data")
	}
	return shim.Success([]byte("Init success"))
}

//Invoke function
func (t *AssetChaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response {
	fun, args := stub.GetFunctionAndParameters()
	if fun == "set" {
		return set(stub, args)
	} else if fun == "get" {
		return get(stub, args)
	} else if fun == "payment" {
		return payment(stub, args)
	} else if fun == "del" {
		return del(stub, args)
	} else if fun == "find" {
		return find(stub, args)
	}
	return shim.Error("not have this ability")
}

//find function
func find(stub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args) != 1 {
		return shim.Error("the number of parameters must one")
	}
	result, err := stub.GetState(args[0])
	if err != nil {
		return shim.Error("occor error when reading the data")
	}
	if result == nil {
		return shim.Error("no data by the key")
	}
	return shim.Success(result)
}

//payment function
func payment(stub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args) != 3 {
		return shim.Error("payment format error")
	}

	var source, target string
	source = args[0]
	target = args[1]
	asset, err := strconv.Atoi(args[2])
	if err != nil {
		return shim.Error("transfer amount atoi failed")
	}
	sourceS, err := stub.GetState(source)
	if err != nil {
		return shim.Error("query source asset failed")
	}
	targetS, err := stub.GetState(target)
	if err != nil {
		return shim.Error("query target asset failed")
	}
	sourceasset, err := strconv.Atoi(string(sourceS))
	if err != nil {
		return shim.Error("source asset transform int failed")
	}
	targetasset, err := strconv.Atoi(string(targetS))
	if err != nil {
		return shim.Error("target asset transform int failed")
	}
	if sourceasset < asset {
		return shim.Error("source asset don\'t have enough balance")
	}
	sourceasset -= asset
	targetasset += asset
	err = stub.PutState(source, []byte(strconv.Itoa(sourceasset)))
	if err != nil {
		return shim.Error("after save payment soure asset failed")
	}
	err = stub.PutState(target, []byte(strconv.Itoa(targetasset)))
	if err != nil {
		return shim.Error("after save payment target asset failed")
	}
	return shim.Success([]byte("payment success"))
}

//delete function
func del(stub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args)!=1{
		return shim.Error("elete account format error")
	}
	err := stub.DelState(args[0])
	if err!= nil{
		return shim.Error("delete account error")
	}
	return shim.Success([]byte("delete account success"+args[0]))
}

//set function
func set(stub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args) != 2 {
		return shim.Error("set account asset format error")
	}
	result, err := stub.GetState(args[0])
	if err != nil {
		return shim.Error("occor error when reading the data")
	}
	if result == nil {
		return shim.Error("no data by the key")
	}
	asset,err := strconv.Atoi(string(result))
	if err!= nil{
		return shim.Error("transfrom account balance error")
	}
	val,err := strconv.Atoi(string(args[1]))
	if err!= nil{
		return shim.Error("transfrom set balance error")
	}
	val += asset
	err = stub.PutState(args[0],[]byte(strconv.Itoa(val)))
	if err != nil {
		return shim.Error("save balance error")
	}
	return shim.Success([]byte("set asset success!"))
}

//get function
func get(stub shim.ChaincodeStubInterface, args []string) peer.Response {
	if len(args) != 2 {
		return shim.Error("t account asset format error")
	}
	result, err := stub.GetState(args[0])
	if err != nil {
		return shim.Error("occor error when reading the data")
	}
	if result == nil {
		return shim.Error("no data by the key")
	}
	asset,err := strconv.Atoi(string(result))
	if err!= nil{
		return shim.Error("transfrom account balance error")
	}
	val,err := strconv.Atoi(string(args[1]))
	if err!= nil{
		return shim.Error("transfrom set balance error")
	}
	if asset<val{
		return shim.Error("not have enough asset")
	}
	asset -= val
	err = stub.PutState(args[0],[]byte(strconv.Itoa(asset)))
	if err != nil {
		return shim.Error("save balance error")
	}
	return shim.Success([]byte("get asset success!"))
}

//main function
func main() {
	err := shim.Start(new(AssetChaincode))
	if err != nil {
		fmt.Printf("start assetchaincode error!,the message is :%s", err)
	}
}

客服电话

电子邮件

Hyperledger fabric 链码篇GO（四）

Hyperledger fabric 链码篇GO（四）

1、常识

2、函数及链码基本结构

2.1、基本结构

2.2、Init函数

2.3、Invoke函数

3、账本操作API

ChaincodeStubInterface

3.1、参数解析API

GetFunctionAndParameters

3.2、账本数据状态操作API

GetState

PutState

DelState

GetStateByRange

GetHistoryForKey

CreateCompositeKey

SplitCompositeKey

GetQueryResult

InvokeChaincode

3.3、交易信息API

GetTxID

GetChannelID

GetTxTimestamp

GetBinding

GetSignedProposal

GetTransient

3.4、事件处理API

SetEvent

3.5、对PrivateData操作的API

4、背书策略

5、应用示例

请发表评论

全部评论

上一篇：

下一篇：

关于我们

产品与服务

解决方案

139-2527-9053