Hyperledger fabric 链码部署

最新推荐文章于 2023-12-06 18:21:43 发布
最新推荐文章于 2023-12-06 18:21:43 发布
阅读量2.1k 收藏 20
点赞数 2
分类专栏： 区块链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42024384/article/details/102462848
版权

文章目录


链码的概念与使用

一、写链码

每个chaincode程序都必须实现 chiancode接口 ，接口中的方法会在响应传来的交易时被调用。特别地，Init（初始化）方法会在chaincode接收到instantiate（实例化）或者upgrade(升级)交易时被调用，进而使得chaincode顺利执行必要的初始化操作，包括初始化应用的状态；Invoke（调用）方法会在响应invoke（调用）交易时被调用以执行交易。

对于每一个chaincode，它都会实现预定义的chaincode接口，特别是Init和Invoke函数接口。所以我们首先为我们的chaincode引入必要的依赖。我们将在此引入chaincode shim package和peer protobuf package。

package main

import (
    "fmt"

    "github.com/hyperledger/fabric/core/chaincode/shim"
    "github.com/hyperledger/fabric/protos/peer"
)

(1) 初始化Chaincode

链码必须有的2个方法

func (t *SimpleAsset) Init(stub shim.ChaincodeStubInterface) peer.Response {
    // do something
    return shim.Success(nil)
}

func (t TokenChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	function, args := stub.GetFunctionAndParameters()

	if function == "" {
		return shim.Error("no function err")
	} else if function == "balance" {
		return t.Balance(stub, args)
	} else if function == "allowance" {
		return t.Allowance(stub, args)
	} 

	log.Errorf("%s was not found", function)
	return shim.Error(fmt.Sprintf("%s was not found", function))
}

值得留意的是chaincode升级同样会调用该函数。当我们编写的chaincode会升级现有chaincode时，需要确保适当修正Init函数。特别地，如果没有“迁移”操作或其他需要在升级中初始化的东西，那么就提供一个空的“Init”方法。

二、打包链码

(1) 什么是智能合约包：

  • 智能合约由智能合约部署规范（ChaincodeDeploymentSpec）或CDS定义。CDS是根据代币和其他属性（如名称和版本）定义的智能合约包
  • 一个可选的实例化策略。
  • 由“拥有”智能合约的实体的一组签名

(2) 签名的目的

  • 为了建立智能和的所有权
  • 允许对包的内容进行验证
  • 允许检测包是否篡改

(3) 怎样创建package(包)

打包合约有两种方法。

  • 一种是当想要一个智能合约拥有多个所有者时，需要多个身份标志为该合约签名。首先创建一个已签名的智能合约（一个签署的CDS）,让后通过序列的方式将其传递给其他所有者来签署。
  • 另一种，正在发行安装事务的节点的身份签名时部署己签署的 CDS

下面是打包一个智能合约的包

peer chaincode package -n $CC_NAME -p github.com/chaincode/justincc/demo1 -v $CC_VERSION -s -S -i "AND('Org1MSP.admin')" ccpack.out

参数说明：

  • -s 参数是指可以创建由多个所有者签署的包，而不是简单的创建一个未处理成修饰过的CDS。当指定了-s时，如果其他所有者需要签名，也必须指定-s参数。否则，这个过程会创建一个除了CDS实例化策略之外的已签署的CDS
  • -S 参数使用在core.yaml中有LocakMspid属性值标志的MSP来指示该程序的签名，这个参数是可选的，如果一个包没有签名的情况下创建的，那么它就不能由任何其他所有者使用signpackage命令来签署
  • -i参数可选的，即指定智能合约实例化策略。实例化策略和背书策略具有相同的格式。实例化链码一节中有介绍。如果没有提供策略，则使用默认策略，这将默认允许channel的任何MSP的admin身份来实例化智能合约

(4) 签名package(包)

一个已经被签名的智能合约包在创建时候可以交友其他所有者检查并签名，这个工作流程支持智能合约包带外签名。

peer chaincode signpackage ccpack.out signedccpack.out

ccpack.out 和signedccpack.out分别是输入包和输出包, 输出包包含了使用本地MSP签名的包的附加签名

输出包又叫做SignedCDS,包含了

  • CDS包含了智能合约的源码，名称和版本信息
  • 智能合约的实例化策略，即背书策略。
  • 智能合约的所有者列表，以背书的方式定义

三、部署链码

部署链码，是在cli容器中进行的。所有需要执行下面的命令，进入cli容器内部：

sudo docker exec -it cli bash

3.0 环境变量

设置临时环境变量，方便下面的命令，反复执行的时候，修改的麻烦。

export CHANNEL_NAME="mychannel"
export CC_NAME="demo1"
export CC_VERSION="1.0"
export ORDERER_CA="/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem"
  • CHANNEL_NAME 通道名
  • CC_NAME 智能合约的名称
  • CC_VERSION 合约的版本
  • ORDERER_CA Orderer服务的证书

3.1 安装链码

安装交易将智能合约的源代码打包成一种指定的格式，称为ChaincodeDeploymentSpec(智能合约部署规范或CDS)，并将其安装到运行该智能合约的Peer节点上。

peer chaincode install -n $CC_NAME -v $CC_VERSION -p github.com/chaincode/justincc/demo1
  • -p参数是链码的源代码路径，根据$GOPATH/src来寻址的

安装交易实质上：是将一个签署的提案发送到生命周期系统智能合约（Lifecycle System chaincode, LSCC）。

注意：必须在channel中的每个背书节点上安装智能合约，才能正常运行智能合约。

3.2 实例化链码

peer chaincode instantiate -o orderer.example.com:7050 --tls --cafile $ORDERER_CA -C $CHANNEL_NAME -n $CC_NAME -v $CC_VERSION -c '{"Args":["init","0x4e9ce36e442e55ecd9025b9a6e0d88485d628a67", "10000"]}' -P "OR ('Org1MSP.peer','Org2MSP.peer')"

注意 -P选项，设置背书策略，

EXPR(E[, E ... ])

EXPR 使用 AND OR其中之作为表达式， 要么是一个，要么一个 EXPR 的嵌套结构

  • ( l ) AND(’Org1.member，’Org2.member’，’Org3.member’）三个主体必须同时背书并认可
    签名
  • (2) OR(’Org1.member,'Org1.member'）两个主体中的任意一个背书并认可签名
  • (3) OR(’Orgl.member', AND('Org2.member','Org3.member’)) 主体1背书 认可签名或者主2
    和主体3同时背书并认可签名

3.3 查询

智能合约可以直接访问本身的状态：

 peer chaincode query -C $CHANNEL_NAME -n $CC_NAME -c '{"Args":["balanceOf","0x4e9ce36e442e55ecd9025b9a6e0d88485d628a67"]}'

正常情况下，不同智能合约是不能直接访问的。当它们在同一个网络中，可以通过给与适当的权限，达到跨合约访问的目的，不同通道直接，只能查询状态。

3.4 执行

peer chaincode invoke -o orderer.example.com:7050 --tls true --cafile $ORDERER_CA -C $CHANNEL_NAME -n $CC_NAME --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 -c '{"Args":["transfer","0x4e9ce36e442e55ecd9025b9a6e0d88485d628a67","0x742d35cc6634c0532925a3b844bc454e4438f44e","1000"]}'

执行后，再执行查询，结果应该是9000,

下面是一个需要2个节点背书的链码demo，全操作：

export CHANNEL_NAME="mychannel"
export CC_NAME="demo1"
export CC_VERSION="1.0"
export CC_PATH="github.com/chaincode/justincc/demo1"
export ORDERER_CA="/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem"


# 在节点 peer0.org1 安装链码
peer chaincode install -n $CC_NAME -v $CC_VERSION -p $CC_PATH

# 实例化链码
peer chaincode instantiate -o orderer.example.com:7050 --tls --cafile $ORDERER_CA -C $CHANNEL_NAME -n $CC_NAME -v $CC_VERSION -c '{"Args":["init","0x4e9ce36e442e55ecd9025b9a6e0d88485d628a67", "10000"]}' -P "AND ('Org1MSP.peer','Org2MSP.peer')"

# 查询已经实例化的链码
peer chaincode query -C $CHANNEL_NAME -n $CC_NAME -c '{"Args":["balanceOf","0x4e9ce36e442e55ecd9025b9a6e0d88485d628a67"]}'

# 切换到 peer0.org2 节点
CORE_PEER_LOCALMSPID="Org2MSP"
CORE_PEER_ADDRESS=peer0.org2.example.com:7051
CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/users/Admin@org2.example.com/msp
CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt

# 在节点 peer0.org2 安装链码
peer chaincode install -n $CC_NAME -v $CC_VERSION -p $CC_PATH

# 调用，同时向2个组织的节点请求背书，发起函数调用。修改账本
peer chaincode invoke -o orderer.example.com:7050 --tls true --cafile $ORDERER_CA -C $CHANNEL_NAME -n $CC_NAME --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:7051 --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt -c '{"Args":["transfer","0x4e9ce36e442e55ecd9025b9a6e0d88485d628a67","0x742d35cc6634c0532925a3b844bc454e4438f44e","1000"]}'

# 查询已经实例化的链码
peer chaincode query -C $CHANNEL_NAME -n $CC_NAME -c '{"Args":["balanceOf","0x742d35cc6634c0532925a3b844bc454e4438f44e"]}'

3.5 升级链码

在升级之前，必须将智能合约的新版本安装在需要的背书Peer上。升级类似实例化的交易，它将智能合约新版本绑定到Channel。不会影响其合约。旧版本的智能合约并不会自动删除。请自行管理旧版本的合约。

升级合约，是根据当前的智能合约实例化中指定的策略进行检查的，而不是新版的策略。意味着升级合约的这笔交易还是按照旧合约的背书策略进行的。

升级活成中，调用chaincode Init 函数执行任何和数据相关的更新或其他操作，因此在升级智能合约时必须注意避免重新设置状态。

3.6 调试

export FABRIC_CFG_PATH="/home/justin/go/src/github.com/hyperledger/fabric/sampleconfig"

启动调试

peer node start --peer-chaincodedev

四、查看记录

4.1 容器日志

检查每个独立的链码服务容器来查看每个容器内的分隔的交易。下面是每个链码服务容器的日志的组合：

sudo docker logs dev-peer0.org1.example.com-demo1-1.0

获取的是链码中自定义的print语句输出的结果。

4.2 链信息

peer channel getinfo -c mychannel

打印结果

Blockchain info: {"height":6,"currentBlockHash":"3WXFNm1NazzMlT4eSUfZGFrxuZKb8/TK/VtDg6yhz8U=","previousBlockHash":"KP20sPqasvkejG1PcJk9qzcL2vDAXIeS2BtJaoeOPv0="}

4.3 块数据

分别查询对应的块数据，以文件的形式保存在当前工作目录

peer channel fetch newest -c mychannel
peer channel fetch oldest -c mychannel
peer channel fetch config -c mychannel
peer channel fetch number -c mychannel

4.4 交易信息

五、测试

示例：

在开发完链码后，我们并不需要在区块链环境中部署链码才能进行调试。可以利用shim.MockStub 来编写单元测试代码，直接在无网络的环境中debug。

package main

import (
	"fmt"
	"testing"
	"github.com/hyperledger/fabric/core/chaincode/shim"
)

// 初始化链码
func mockInit(t *testing.T, stub *shim.MockStub, args [][]byte) {
	res := stub.MockInit("1", args)
	if res.Status != shim.OK {
		fmt.Println("Init failed", string(res.Message))
		t.FailNow()
	}
}

// 调用函数
func initSchool(t *testing.T, stub *shim.MockStub, args []string) {
	res := stub.MockInvoke("1", [][]byte{
        []byte("initSchool"), []byte(args[0]), []byte(args[1])
    })
	
	if res.Status != shim.OK {
		fmt.Println("InitSchool failed:", args[0], string(res.Message))
		t.FailNow()
	}
}

// 单元测试
func TestInitSchool(t *testing.T) {
	scc := new(StudentChaincode)
	stub := shim.NewMockStub("StudentChaincode", scc)
	mockInit(t, stub, nil)
	initSchool(t, stub, []string{"schoolId_A", "学校1"})
	initSchool(t, stub, []string{"schoolId_B", "学校2"})
}

八、附录

  • 不能使用不确定性的变聋作为计算的输入 比如不能采用随机数或者获取系统当前时间等 链码会在不同的节点上多次运行，但是运行的时间并不严格一致，环境的查询导致不同节点上执行的结果不一致，最终无法达成共识
  • 避免调用外部数据接口导致重复计算：比如多个节点多次调用外部写数据的接口，可能会导致区块链外部重复计算 这种情况多个链码的执行结果可能是一致的，不会导致共识失败，但会影响外部的一致性，这是一种逻辑错误

九、附录

链码调用链码

/*
Copyright IBM Corp. All Rights Reserved.

SPDX-License-Identifier: Apache-2.0
*/

package example04

import (
	"fmt"
	"strconv"

	"github.com/hyperledger/fabric/core/chaincode/shim"
	pb "github.com/hyperledger/fabric/protos/peer"
)

// This chaincode is a test for chaincode invoking another chaincode - invokes chaincode_example02

// SimpleChaincode example simple Chaincode implementation
type SimpleChaincode struct{}

func toChaincodeArgs(args ...string) [][]byte {
	bargs := make([][]byte, len(args))
	for i, arg := range args {
		bargs[i] = []byte(arg)
	}
	return bargs
}

// Init takes two arguments, a string and int. These are stored in the key/value pair in the state
func (t *SimpleChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
	var event string // Indicates whether event has happened. Initially 0
	var eventVal int // State of event
	var err error
	_, args := stub.GetFunctionAndParameters()
	if len(args) != 2 {
		return shim.Error("Incorrect number of arguments. Expecting 2")
	}

	// Initialize the chaincode
	event = args[0]
	eventVal, err = strconv.Atoi(args[1])
	if err != nil {
		return shim.Error("Expecting integer value for event status")
	}
	fmt.Printf("eventVal = %d\n", eventVal)

	err = stub.PutState(event, []byte(strconv.Itoa(eventVal)))
	if err != nil {
		return shim.Error(err.Error())
	}

	return shim.Success(nil)
}

// Invoke invokes another chaincode - chaincode_example02, upon receipt of an event and changes event state
func (t *SimpleChaincode) invoke(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	var event string // Event entity
	var eventVal int // State of event
	var err error

	if len(args) != 3 && len(args) != 4 {
		return shim.Error("Incorrect number of arguments. Expecting 3 or 4")
	}

	chainCodeToCall := args[0]
	event = args[1]
	eventVal, err = strconv.Atoi(args[2])
	if err != nil {
		return shim.Error("Expected integer value for event state change")
	}
	channelID := ""
	if len(args) == 4 {
		channelID = args[3]
	}

	if eventVal != 1 {
		fmt.Printf("Unexpected event. Doing nothing\n")
		return shim.Success(nil)
	}

	f := "invoke"
	invokeArgs := toChaincodeArgs(f, "a", "b", "10")
	response := stub.InvokeChaincode(chainCodeToCall, invokeArgs, channelID)
	if response.Status != shim.OK {
		errStr := fmt.Sprintf("Failed to invoke chaincode. Got error: %s", string(response.Payload))
		fmt.Printf(errStr)
		return shim.Error(errStr)
	}

	fmt.Printf("Invoke chaincode successful. Got response %s", string(response.Payload))

	// Write the event state back to the ledger
	err = stub.PutState(event, []byte(strconv.Itoa(eventVal)))
	if err != nil {
		return shim.Error(err.Error())
	}

	return response
}

func (t *SimpleChaincode) query(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	var event string // Event entity
	var err error

	if len(args) < 1 {
		return shim.Error("Incorrect number of arguments. Expecting entity to query")
	}

	event = args[0]
	var jsonResp string

	// Get the state from the ledger
	eventValbytes, err := stub.GetState(event)
	if err != nil {
		jsonResp = "{\"Error\":\"Failed to get state for " + event + "\"}"
		return shim.Error(jsonResp)
	}

	if eventValbytes == nil {
		jsonResp = "{\"Error\":\"Nil value for " + event + "\"}"
		return shim.Error(jsonResp)
	}

	if len(args) > 3 {
		chainCodeToCall := args[1]
		queryKey := args[2]
		channel := args[3]
		f := "query"
		invokeArgs := toChaincodeArgs(f, queryKey)
		response := stub.InvokeChaincode(chainCodeToCall, invokeArgs, channel)
		if response.Status != shim.OK {
			errStr := fmt.Sprintf("Failed to invoke chaincode. Got error: %s", err.Error())
			fmt.Printf(errStr)
			return shim.Error(errStr)
		}
		jsonResp = string(response.Payload)
	} else {
		jsonResp = "{\"Name\":\"" + event + "\",\"Amount\":\"" + string(eventValbytes) + "\"}"
	}
	fmt.Printf("Query Response: %s\n", jsonResp)

	return shim.Success([]byte(jsonResp))
}

// Invoke is called by fabric to execute a transaction
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	function, args := stub.GetFunctionAndParameters()
	if function == "invoke" {
		return t.invoke(stub, args)
	} else if function == "query" {
		return t.query(stub, args)
	}

	return shim.Error("Invalid invoke function name. Expecting \"invoke\" \"query\"")
}

链码查询链码

/*
Copyright IBM Corp. All Rights Reserved.

SPDX-License-Identifier: Apache-2.0
*/

package example05

import (
	"fmt"
	"strconv"

	"github.com/hyperledger/fabric/core/chaincode/shim"
	pb "github.com/hyperledger/fabric/protos/peer"
)

// This chaincode is a test for chaincode querying another chaincode - invokes chaincode_example02 and computes the sum of a and b and stores it as state

// SimpleChaincode example simple Chaincode implementation
type SimpleChaincode struct{}

func toChaincodeArgs(args ...string) [][]byte {
	bargs := make([][]byte, len(args))
	for i, arg := range args {
		bargs[i] = []byte(arg)
	}
	return bargs
}

// Init takes two arguments, a string and int. The string will be a key with
// the int as a value.
func (t *SimpleChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
	var sum string // Sum of asset holdings across accounts. Initially 0
	var sumVal int // Sum of holdings
	var err error
	_, args := stub.GetFunctionAndParameters()
	if len(args) != 2 {
		return shim.Error("Incorrect number of arguments. Expecting 2")
	}

	// Initialize the chaincode
	sum = args[0]
	sumVal, err = strconv.Atoi(args[1])
	if err != nil {
		return shim.Error("Expecting integer value for sum")
	}
	fmt.Printf("sumVal = %d\n", sumVal)

	// Write the state to the ledger
	err = stub.PutState(sum, []byte(strconv.Itoa(sumVal)))
	if err != nil {
		return shim.Error(err.Error())
	}

	return shim.Success(nil)
}

// Invoke queries another chaincode and updates its own state
func (t *SimpleChaincode) invoke(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	var sum, channelName string // Sum entity
	var Aval, Bval, sumVal int  // value of sum entity - to be computed
	var err error

	if len(args) < 2 {
		return shim.Error("Incorrect number of arguments. Expecting atleast 2")
	}

	chaincodeName := args[0] // Expecting name of the chaincode you would like to call, this name would be given during chaincode install time
	sum = args[1]

	if len(args) > 2 {
		channelName = args[2]
	} else {
		channelName = ""
	}

	// Query chaincode_example02
	f := "query"
	queryArgs := toChaincodeArgs(f, "a")

	//   if chaincode being invoked is on the same channel,
	//   then channel defaults to the current channel and args[2] can be "".
	//   If the chaincode being called is on a different channel,
	//   then you must specify the channel name in args[2]

	response := stub.InvokeChaincode(chaincodeName, queryArgs, channelName)
	if response.Status != shim.OK {
		errStr := fmt.Sprintf("Failed to query chaincode. Got error: %s", response.Payload)
		fmt.Printf(errStr)
		return shim.Error(errStr)
	}
	Aval, err = strconv.Atoi(string(response.Payload))
	if err != nil {
		errStr := fmt.Sprintf("Error retrieving state from ledger for queried chaincode: %s", err.Error())
		fmt.Printf(errStr)
		return shim.Error(errStr)
	}

	queryArgs = toChaincodeArgs(f, "b")
	response = stub.InvokeChaincode(chaincodeName, queryArgs, channelName)
	if response.Status != shim.OK {
		errStr := fmt.Sprintf("Failed to query chaincode. Got error: %s", response.Payload)
		fmt.Printf(errStr)
		return shim.Error(errStr)
	}
	Bval, err = strconv.Atoi(string(response.Payload))
	if err != nil {
		errStr := fmt.Sprintf("Error retrieving state from ledger for queried chaincode: %s", err.Error())
		fmt.Printf(errStr)
		return shim.Error(errStr)
	}

	// Compute sum
	sumVal = Aval + Bval

	// Write sumVal back to the ledger
	err = stub.PutState(sum, []byte(strconv.Itoa(sumVal)))
	if err != nil {
		return shim.Error(err.Error())
	}

	fmt.Printf("Invoke chaincode successful. Got sum %d\n", sumVal)
	return shim.Success([]byte(strconv.Itoa(sumVal)))
}

func (t *SimpleChaincode) query(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	var sum, channelName string // Sum entity
	var Aval, Bval, sumVal int  // value of sum entity - to be computed
	var err error

	if len(args) < 2 {
		return shim.Error("Incorrect number of arguments. Expecting atleast 2")
	}

	chaincodeName := args[0] // Expecting name of the chaincode you would like to call, this name would be given during chaincode install time
	sum = args[1]

	if len(args) > 2 {
		channelName = args[2]
	} else {
		channelName = ""
	}

	// Query chaincode_example02
	f := "query"
	queryArgs := toChaincodeArgs(f, "a")

	//   if chaincode being invoked is on the same channel,
	//   then channel defaults to the current channel and args[2] can be "".
	//   If the chaincode being called is on a different channel,
	//   then you must specify the channel name in args[2]
	response := stub.InvokeChaincode(chaincodeName, queryArgs, channelName)
	if response.Status != shim.OK {
		errStr := fmt.Sprintf("Failed to query chaincode. Got error: %s", response.Payload)
		fmt.Printf(errStr)
		return shim.Error(errStr)
	}
	Aval, err = strconv.Atoi(string(response.Payload))
	if err != nil {
		errStr := fmt.Sprintf("Error retrieving state from ledger for queried chaincode: %s", err.Error())
		fmt.Printf(errStr)
		return shim.Error(errStr)
	}

	queryArgs = toChaincodeArgs(f, "b")
	response = stub.InvokeChaincode(chaincodeName, queryArgs, channelName)
	if response.Status != shim.OK {
		errStr := fmt.Sprintf("Failed to query chaincode. Got error: %s", response.Payload)
		fmt.Printf(errStr)
		return shim.Error(errStr)
	}
	Bval, err = strconv.Atoi(string(response.Payload))
	if err != nil {
		errStr := fmt.Sprintf("Error retrieving state from ledger for queried chaincode: %s", err.Error())
		fmt.Printf(errStr)
		return shim.Error(errStr)
	}

	// Compute sum
	sumVal = Aval + Bval

	fmt.Printf("Query chaincode successful. Got sum %d\n", sumVal)
	jsonResp := "{\"Name\":\"" + sum + "\",\"Value\":\"" + strconv.Itoa(sumVal) + "\"}"
	fmt.Printf("Query Response:%s\n", jsonResp)
	return shim.Success([]byte(strconv.Itoa(sumVal)))
}

func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	function, args := stub.GetFunctionAndParameters()
	if function == "invoke" {
		return t.invoke(stub, args)
	} else if function == "query" {
		return t.query(stub, args)
	}

	return shim.Success([]byte("Invalid invoke function name. Expecting \"invoke\" \"query\""))
}
小皮蛋啦啦啦
关注
专栏目录
Hyperledger Fabric 链码开发-常用函数
区块链领域填坑的java程序猿
10-23 285
目前，Fabric的开发主要分为两部分，一是链码及智能合约的开发，二是基于SDK的应用开发。我们一般提到区块链都会关注智能合约的开发，因为它是区块链与外部连接的触手，同时，也是区块链实现自动执行，减少人为干预的重要手段。但是区块链要实现与业务系统的对接，仅仅靠智能合约是无法实现的，它还需要SDK以及相关应用的开发。除了header指向下一个block的hash value外，block是由一组transaction构成, Transactions --> Blocks --> Ledger。 Chainco
Centos7 HyperLedger Fabric 1.4 生产环境部署
01-20
在本文中，我们将深入探讨如何在CentOS 7系统上部署Hyperledger Fabric 1.4的生产环境。Hyperledger Fabric是IBM和Linux基金会发起的区块链框架，它为企业提供了可扩展性和隐私性，使得构建分布式账本应用成为可能。...
Fabric1.1.0链码部署
yuch_hong的博客
07-15 478
上传链码至宿主机目录 删除已存在的go文件，上传新的文件。 拷贝链码到docker容器里面 在docker容器中操作 docker exec -it cli bash cd /opt/gopath/src/github.com/hyperledger/fabric/mylc/chaincode/go/digital-rights/ 删除已存在的文件 rm -rf * 在宿主机进行chaincode拷贝 docker cp /www/fabric-chaincode/d..
HyperLedger Fabric部署与链码解读
weixin_33872660的博客
05-27 729
1.Fabric简介 Fabric是超级账本中的一个项目，用以推进区块链技术。和其他区块链类似，它也有一个账本，使用智能合约，且是一个参与者可以分别管理自身交易的系统。它是一个联盟链。Fabric与其他区块链系统最大的不同在于它是隐私的、许可的网络。相对于像其他区块链那样通过“工作量证明”来验证身份（允许任何人加入网络），Fabric的成员通过会员注册服务提供商来加入网络。Fabric提供了多...
Hyperledger Fabric网络环境手动配置及其链码自动化部署
weixin_44770382的博客
06-11 3934
区块链具有去中心化、可验证、不可串改等特性，通过与密码学结合可以增强系统的安全性。区块链最核心的功能是存储(记账)功能，类似于一种特殊的数据库系统。系统以Linux系统作为开发环境，选用Hyperledger Fabric框架进行开发，通过Golong语言编写链码，手动搭建Hyperledger Fabric网络环境，实现链码的自动化部署，Fabric项目自动化部署。.........
Ubuntu 18.04上进行HyperLedger Fabric 1.2.0环境及链码安装、部署和测试
小白不百
11-24 978
1、环境安装 HyperLedger Fabric 1.2.0环境的安装推荐一篇博客：https://www.jianshu.com/p/4f58e0fcb9f9 此博客写的非常详细，本人完全按照这个上面安装，但第九步出现了错误，这个错误是因为权限问题，解决方法参考这里。其余地方均未发现问题。 2、链码安装、部署和测试 1、执行./byfn.sh down关闭前面的网络。 2、进入/fa...
Fabric:链码的部署及执行
读万卷书 行万里路
12-06 1860
Tips:peer lifecycle chaincode package命令只是将链码打包成一个tar格式的文件，这个过程不需要与具体的peer节点交互，因此这个命令的执行不需要事先绑定节点。Fabric中链码的部署一般包括以下步骤：编写链码->打包链码->安装链码->实例化链码->部署链码等。Tips: 虽然在fabric_test网络中创建了3个peer节点，但链码不一定需要在所有peer节点上都安装。安装链码主要负责将将链码部署到每个需要执行链码的Peer节点上。查看peer节点已经安装的链码。
Hyperledger Fabric 链码开发实战1
08-04
Hyperledger Fabric 链码开发实战 Hyperledger Fabric 是一个开源的分布式账本技术，旨在提供一个灵活、可扩展、安全的平台，以便开发者构建区块链应用程序。链码是 Fabric 中的一种业务逻辑实现，用于处理具体的...
hyperledger Fabric链码部署
最新发布
08-21
Hyperledger Fabric是一种开源的分布式账本平台，专为企业级区块链应用设计，特别是那些需要高吞吐量、数据隐私和安全性的场景。链码（Smart Contracts）是Fabric的核心组件，它们是运行在节点上的业务逻辑，类似于...
HyperLedger Fabric开发实战——快速掌握区块链技术-配套资源.zip
06-26
《Hyperledger Fabric开发实战——快速掌握区块链技术》是一本深入探讨企业级区块链解决方案Hyperledger Fabric的...通过深入学习和实践，读者将能够设计、部署和管理自己的Hyperledger Fabric网络，解决实际业务问题。
区块链hyperledger fabric部署
zis0926的博客
04-13 1649
1.2 安装curl 1.3 安装docker 1.4 安装go 新建目录、下载、解压 配置环境 1.5 安装JQ 二 安装实例、二进制和docker镜像 2.1 新建目录，克隆 仓库 选择适当的版本标签，进入目录，切换分支 2.2 下载docker镜像 将指定版本的 Hyperledger Fabric 平台特定二进制文件和配置文件安装到 fabric-samples 下的 和 目录中，下载指定版本的 Hyperledger Fabric do
Fabric链码Basic的使用以及部署（release 2.2）
aitutou的博客
04-11 888
#合约描述 此合约是一个基础的实例智能合约，演示如何使用资产初始化分类帐、查询这些资产、创建新资产、基于资产 ID 查询单个资产、更新现有资产以及将资产转让给新所有者。 #准备工作 在开始之前，需要先搭建一下运行fabric智能合约的环境，具体步骤请参见： 原文链接：https://blog.csdn.net/qq_42482245/article/details/109801959 文中需要下载二进制的可执行文件以下载好放入网盘 链接：https://pan.baidu.com/s/1XpGvJ_W7d5
Hyperledger Fabric 实战(六):在开发链上部署测试链码helloworld
weixin_33714884的博客
01-09 607
为什么80%的码农都做不了架构师？>>> ...
Hyperledger Fabric 入门笔记（七）Fabric V2.4 测试网络进阶之链码使用
sbsy123456的博客
07-31 1441
本文参考官方技术文档的教程，说明了Fabric-samples的示例链码的使用。
fabric多机安装链码
qq_23215009的博客
01-26 1103
fabric多机安装链码 一、如何安装链码 1.安装链码 -打包链码，由于这次的例子是基于 go 语言开发的智能合约，会依赖 go 的开发环境进行安装，如果使用 peer chaincode install 命令指定链码路径安装，可能会造成其他虚拟上安装的同样的链码无法同步实例化（go 开发环境不一致引起的问题），所以这里使用 go chaincode package 打包链码，然后通过安装打包链...
Hyperledger fabric-1.1.0 - 7.智能合约【链码概念介绍】
尚
11-08 718
fabric chaincode编码前准备之 智能合约（chaincode）基本概念介绍
自己动手部署区块链-hyperledger/fabric-01
架构狮老颜
12-28 9295
Hyperledger(又名Fabric) 来源于伟大的IBM，从最初IBM将44,000行代码进行开源到现在，已经刚好有100个成员参与其发展，参考以下链接： Hyperledger Community：(https://www.hyperledger.org/community) Hyperledger mailing lists and archives：(http://lists.hyp
实战：区块链hyperledger fabric 初体验 - 3： 链码实例安装、实例化、调用及代码...
weixin_33841722的博客
03-08 895
本文链码实例为Fabric 官方实例examples/chaincode/go/chaincode_example02，实现简单的转账功能进入到cli容器里面$ docker exec -it fabric-cli bash１. 链码安装以在org1, peer0 为例1.1 设置环境变量export CORE_PEER_LOCALMSPID=Org2MSPexport CO...
Hyperledger Fabric教程（12）-- 交易过程
软件工程小施同学 的专栏
01-07 1114
一、申请交易 角色 1. Endorser 背书节点 ，都是peer节点，E0,E1,E2。 一定要部署链码。 2. Commiter 提交节点，记账节点，没有背书功能，都是peer节点，P3,P4 可以没有部署和执行任何链码。 3. Ledger 账本，保存所有交易信息。 每个节点都有一个自己的账本。 4. Application 客户端 5. Orderer 排序节点 可以是一个分布式的 6. Smart Contract（C...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值