hperledger fabric 1.0 源码分析之背书模拟交易过程

最新推荐文章于 2022-05-25 00:30:59 发布
最新推荐文章于 2022-05-25 00:30:59 发布
阅读量2.4k 收藏 2
点赞数 1
分类专栏： 区块链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cs380637384/article/details/81906712
版权

应用程序通过grpc的接口发起请求，请求命令

ProcessProposal(ctx context.Context, signedProp *pb.SignedProposal) (*pb.ProposalResponse, error) {}

背书节点接收到请求以后，会做一些必要的检查，比如权限提交，是否重复提交，真正的执行过程是在链码在完成，ESCC最后对执行结果进行签名背书。中间产生任何异常都会终止后续执行，返回给应用程序。

ProcessProposal的实现

//github.com/hyperledger/fabric/core/endorser/endorser.go
func (e *Endorser) ProcessProposal(ctx context.Context, signedProp *pb.SignedProposal) (*pb.ProposalResponse, error) {
	endorserLogger.Debugf("Entry")
	defer endorserLogger.Debugf("Exit")
	// at first, we check whether the message is valid
    //验证签名过的提案是否有效，验证通过返回提案，头部消息，头部消息扩展
	prop, hdr, hdrExt, err := validation.ValidateProposalMessage(signedProp)
	if err != nil {
		return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
	}
    //对头部通道消息进行反序列化
	chdr, err := putils.UnmarshalChannelHeader(hdr.ChannelHeader)
	if err != nil {
		return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
	}
    //获取头部签名消息
	shdr, err := putils.GetSignatureHeader(hdr.SignatureHeader)
	if err != nil {
		return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
	}

	//阻止对安全敏感系统链代码的调用
	if syscc.IsSysCCAndNotInvokableExternal(hdrExt.ChaincodeId.Name) {
		endorserLogger.Errorf("Error: an attempt was made by %#v to invoke system chaincode %s",
			shdr.Creator, hdrExt.ChaincodeId.Name)
		err = fmt.Errorf("Chaincode %s cannot be invoked through a proposal", hdrExt.ChaincodeId.Name)
		return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
	}

	chainID := chdr.ChannelId

	// Check for uniqueness of prop.TxID with ledger
	// Notice that ValidateProposalMessage has already verified
	// that TxID is computed properly
	txid := chdr.TxId
	if txid == "" {
		err = errors.New("Invalid txID. It must be different from the empty string.")
		return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
	}
	endorserLogger.Debugf("processing txid: %s", txid)
	if chainID != "" {
        //对链中提案唯一性的检查
		// here we handle uniqueness check and ACLs for proposals targeting a chain
		lgr := peer.GetLedger(chainID)
		if lgr == nil {
			return nil, fmt.Errorf("failure while looking up the ledger %s", chainID)
		}
		if _, err := lgr.GetTransactionByID(txid); err == nil {
			return nil, fmt.Errorf("Duplicate transaction found [%s]. Creator [%x]. [%s]", txid, shdr.Creator, err)
		}

		//验证是否为系统链码，如果是，则验证是否可被外部调用
		if !syscc.IsSysCC(hdrExt.ChaincodeId.Name) {
			// check that the proposal complies with the channel's writers
			if err = e.checkACL(signedProp, chdr, shdr, hdrExt); err != nil {
				return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
			}
		}
	} else {
		// chainless proposals do not/cannot affect ledger and cannot be submitted as transactions
		// ignore uniqueness checks; also, chainless proposals are not validated using the policies
		// of the chain since by definition there is no chain; they are validated against the local
		// MSP of the peer instead by the call to ValidateProposalMessage above
	}

	// obtaining once the tx simulator for this proposal. This will be nil
	// for chainless proposals
	// Also obtain a history query executor for history queries, since tx simulator does not cover history
    //获取账本交易模拟器对象txsim，账本历史查询器对象historyQueryExecutor
	var txsim ledger.TxSimulator
	var historyQueryExecutor ledger.HistoryQueryExecutor
	if chainID != "" {
		if txsim, err = e.getTxSimulator(chainID); err != nil {
			return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
		}
		if historyQueryExecutor, err = e.getHistoryQueryExecutor(chainID); err != nil {
			return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
		}
		// Add the historyQueryExecutor to context
		// TODO shouldn't we also add txsim to context here as well? Rather than passing txsim parameter
		// around separately, since eventually it gets added to context anyways
        //将账本历史查询器对象添加到了context中
		ctx = context.WithValue(ctx, chaincode.HistoryQueryExecutorKey, historyQueryExecutor)
		defer txsim.Done()
	}
	//this could be a request to a chainless SysCC

	// TODO: if the proposal has an extension, it will be of type ChaincodeAction;
	//       if it's present it means that no simulation is to be performed because
	//       we're trying to emulate a submitting peer. On the other hand, we need
	//       to validate the supplied action before endorsing it
    //摸拟
	//1 -- simulate
    //背书者使用simulateProposal模拟执行交易
    //返回chaincode数据、执行chaincode的应答信息、模拟结果集合、chaincode的执行事件
	cd, res, simulationResult, ccevent, err := e.simulateProposal(ctx, chainID, txid, signedProp, prop, hdrExt.ChaincodeId, txsim)
	if err != nil {
		return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
	}
    //chaincode应答错误返回的处理
	if res != nil {
		if res.Status >= shim.ERROR {
			endorserLogger.Errorf("simulateProposal() resulted in chaincode response status %d for txid: %s", res.Status, txid)
			var cceventBytes []byte
			if ccevent != nil {
				cceventBytes, err = putils.GetBytesChaincodeEvent(ccevent)
				if err != nil {
					return nil, fmt.Errorf("failed to marshal event bytes - %s", err)
				}
			}
			pResp, err := putils.CreateProposalResponseFailure(prop.Header, prop.Payload, res, simulationResult, cceventBytes, hdrExt.ChaincodeId, hdrExt.PayloadVisibility)
			if err != nil {
				return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
			}

			return pResp, &chaincodeError{res.Status, res.Message}
		}
	}

	//2 -- endorse and get a marshalled ProposalResponse message
	var pResp *pb.ProposalResponse

	//TODO till we implement global ESCC, CSCC for system chaincodes
	//chainless proposals (such as CSCC) don't have to be endorsed
	if chainID == "" {
		pResp = &pb.ProposalResponse{Response: res}
	} else {
        //对模拟交易进行背书
		pResp, err = e.endorseProposal(ctx, chainID, txid, signedProp, prop, res, simulationResult, ccevent, hdrExt.PayloadVisibility, hdrExt.ChaincodeId, txsim, cd)
		if err != nil {
			return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
		}
		if pResp != nil {
            //大于或等于400的状态代码将被认为是错误，并被背书人拒绝。
			if res.Status >= shim.ERRORTHRESHOLD {
				endorserLogger.Debugf("endorseProposal() resulted in chaincode error for txid: %s", txid)
				return pResp, &chaincodeError{res.Status, res.Message}
			}
		}
	}

	// Set the proposal response payload - it
	// contains the "return value" from the
	// chaincode invocation
	pResp.Response.Payload = res.Payload

	return pResp, nil
}

 ValidateProposalMessage对应用程序提交的signedProp进行验证，并返回Proposal,Header和ChaincodeHeaderExtension消息。

func ValidateProposalMessage(signedProp *pb.SignedProposal) (*pb.Proposal, *common.Header, *pb.ChaincodeHeaderExtension, error) {
	if signedProp == nil {
		return nil, nil, nil, errors.New("Nil arguments")
	}

	putilsLogger.Debugf("ValidateProposalMessage starts for signed proposal %p", signedProp)

	//从signedProp中提取Proposal消息
	prop, err := utils.GetProposal(signedProp.ProposalBytes)
	if err != nil {
		return nil, nil, nil, err
	}

	// 1) 提取Header
	hdr, err := utils.GetHeader(prop.Header)
	if err != nil {
		return nil, nil, nil, err
	}

	// 验证Header中的channelHeader和signatureHeader并返回
	chdr, shdr, err := validateCommonHeader(hdr)
	if err != nil {
		return nil, nil, nil, err
	}

	//checkSignatureFromCreator验证了SignedProposal中的证书、背书策略，发起者的身份等的有效性
	err = checkSignatureFromCreator(shdr.Creator, signedProp.Signature, signedProp.ProposalBytes, chdr.ChannelId)
	if err != nil {
		return nil, nil, nil, err
	}

	// 验证txid，重复性校验
	err = utils.CheckProposalTxID(
		chdr.TxId,
		shdr.Nonce,
		shdr.Creator)
	if err != nil {
		return nil, nil, nil, err
	}

	//根据交易header中类型验证
	switch common.HeaderType(chdr.Type) {
	case common.HeaderType_CONFIG:
		//which the types are different the validation is the same
		//viz, validate a proposal to a chaincode. If we need other
		//special validation for confguration, we would have to implement
		//special validation
		fallthrough
	case common.HeaderType_ENDORSER_TRANSACTION:
		// validation of the proposal message knowing it's of type CHAINCODE
		chaincodeHdrExt, err := validateChaincodeProposalMessage(prop, hdr)
		if err != nil {
			return nil, nil, nil, err
		}

		return prop, hdr, chaincodeHdrExt, err
	default:
		//NOTE : we proably need a case
		return nil, nil, nil, fmt.Errorf("Unsupported proposal type %d", common.HeaderType(chdr.Type))
	}
}

因为validation.ValidateProposalMessage的返回中并没有返回ChannelHeader和SignatureHeader，所以重新提取了一次（在validation.ValidateProposalMessage中是由validateCommonHeader内进行的提取）

func validateCommonHeader(hdr *common.Header) (*common.ChannelHeader, *common.SignatureHeader, error) {
	if hdr == nil {
		return nil, nil, errors.New("Nil header")
	}

	chdr, err := utils.UnmarshalChannelHeader(hdr.ChannelHeader)
	if err != nil {
		return nil, nil, err
	}

	shdr, err := utils.GetSignatureHeader(hdr.SignatureHeader)
	if err != nil {
		return nil, nil, err
	}

	err = validateChannelHeader(chdr)
	if err != nil {
		return nil, nil, err
	}

	err = validateSignatureHeader(shdr)
	if err != nil {
		return nil, nil, err
	}

	return chdr, shdr, nil
}

接着IsSysCCAndNotInvokableExternal验证signedProp中的chaincode ID是否系统chaincode。如果该chaincodeID是系统chaincode且不能被外部调用，则返回true，则进入if分支，返回相应错误。这表明，发送signedProp所在的chaincode，若是系统chaincode时，要保证该系统chaincode允许被外界调用。在系统chaincode中，InvokableExternal字段设定了是否可以被外界调用。

func IsSysCCAndNotInvokableExternal(name string) bool {
	for _, sysCC := range systemChaincodes {
		if sysCC.Name == name {
			return !sysCC.InvokableExternal
		}
	}
	return false
}

var systemChaincodes = []*SystemChaincode{
	{
		Enabled:           true,
		Name:              "cscc",
		Path:              "github.com/hyperledger/fabric/core/scc/cscc",
		InitArgs:          [][]byte{[]byte("")},
		Chaincode:         &cscc.PeerConfiger{},
		InvokableExternal: true, // cscc is invoked to join a channel
	},
	{
		Enabled:           true,
		Name:              "lscc",
		Path:              "github.com/hyperledger/fabric/core/scc/lscc",
		InitArgs:          [][]byte{[]byte("")},
		Chaincode:         &lscc.LifeCycleSysCC{},
		InvokableExternal: true, // lscc is invoked to deploy new chaincodes
		InvokableCC2CC:    true, // lscc can be invoked by other chaincodes
	},
	{
		Enabled:   true,
		Name:      "escc",
		Path:      "github.com/hyperledger/fabric/core/scc/escc",
		InitArgs:  [][]byte{[]byte("")},
		Chaincode: &escc.EndorserOneValidSignature{},
	},
	{
		Enabled:   true,
		Name:      "vscc",
		Path:      "github.com/hyperledger/fabric/core/scc/vscc",
		InitArgs:  [][]byte{[]byte("")},
		Chaincode: &vscc.ValidatorOneValidSignature{},
	},
	{
		Enabled:           true,
		Name:              "qscc",
		Path:              "github.com/hyperledger/fabric/core/chaincode/qscc",
		InitArgs:          [][]byte{[]byte("")},
		Chaincode:         &qscc.LedgerQuerier{},
		InvokableExternal: true, // qscc can be invoked to retrieve blocks
		InvokableCC2CC:    true, // qscc can be invoked to retrieve blocks also by a cc
	},
}

然后判断txid和chainID是否存在，当chainID不为空时，获取对应的账本对象lgr，接着在账本中查询txid是否在账本中存在，进行唯一校验。接下来判断，如果不是系统chaincode,进行背书策略检查。

func (e *Endorser) checkACL(signedProp *pb.SignedProposal, chdr *common.ChannelHeader, shdr *common.SignatureHeader, hdrext *pb.ChaincodeHeaderExtension) error {
	return e.policyChecker.CheckPolicy(chdr.ChannelId, policies.ChannelApplicationWriters, signedProp)
}

通过背书policyChecker.CheckPolicy进行背书策略验证。

//github.com/hyperledger/fabric/core/policy/policy.go

func (p *policyChecker) CheckPolicy(channelID, policyName string, signedProp *pb.SignedProposal) error {
	if channelID == "" {
		return p.CheckPolicyNoChannel(policyName, signedProp)
	}

	if policyName == "" {
		return fmt.Errorf("Invalid policy name during check policy on channel [%s]. Name must be different from nil.", channelID)
	}

	if signedProp == nil {
		return fmt.Errorf("Invalid signed proposal during check policy on channel [%s] with policy [%s]", channelID, policyName)
	}

	// Get Policy
	policyManager, _ := p.channelPolicyManagerGetter.Manager(channelID)
	if policyManager == nil {
		return fmt.Errorf("Failed to get policy manager for channel [%s]", channelID)
	}

	// Prepare SignedData
	proposal, err := utils.GetProposal(signedProp.ProposalBytes)
	if err != nil {
		return fmt.Errorf("Failing extracting proposal during check policy on channel [%s] with policy [%s]: [%s]", channelID, policyName, err)
	}

	header, err := utils.GetHeader(proposal.Header)
	if err != nil {
		return fmt.Errorf("Failing extracting header during check policy on channel [%s] with policy [%s]: [%s]", channelID, policyName, err)
	}

	shdr, err := utils.GetSignatureHeader(header.SignatureHeader)
	if err != nil {
		return fmt.Errorf("Invalid Proposal's SignatureHeader during check policy on channel [%s] with policy [%s]: [%s]", channelID, policyName, err)
	}

	sd := []*common.SignedData{&common.SignedData{
		Data:      signedProp.ProposalBytes,
		Identity:  shdr.Creator,
		Signature: signedProp.Signature,
	}}

	return p.CheckPolicyBySignedData(channelID, policyName, sd)
}

当chainID不为空时，根据chainID获取交易模拟对象和账本历史查询对象，进行模拟（simulate）交易。

func (*Endorser) getTxSimulator(ledgername string) (ledger.TxSimulator, error) {
	lgr := peer.GetLedger(ledgername)
	if lgr == nil {
		return nil, fmt.Errorf("channel does not exist: %s", ledgername)
	}
	return lgr.NewTxSimulator()
}
func (*Endorser) getHistoryQueryExecutor(ledgername string) (ledger.HistoryQueryExecutor, error) {
	lgr := peer.GetLedger(ledgername)
	if lgr == nil {
		return nil, fmt.Errorf("channel does not exist: %s", ledgername)
	}
	return lgr.NewHistoryQueryExecutor()
}

通过背书中的simulateProposal模拟执行，最终返回chaincode数据、执行chaincode的应答信息、模拟结果集合、chaincode的执行事件。

func (e *Endorser) simulateProposal(ctx context.Context, chainID string, txid string, signedProp *pb.SignedProposal, prop *pb.Proposal, cid *pb.ChaincodeID, txsim ledger.TxSimulator) (*ccprovider.ChaincodeData, *pb.Response, []byte, *pb.ChaincodeEvent, error) {
	endorserLogger.Debugf("Entry - txid: %s channel id: %s", txid, chainID)
	defer endorserLogger.Debugf("Exit")
	//we do expect the payload to be a ChaincodeInvocationSpec
	//if we are supporting other payloads in future, this be glaringly point
	//as something that should change
	cis, err := putils.GetChaincodeInvocationSpec(prop)
	if err != nil {
		return nil, nil, nil, nil, err
	}

	//disable Java install,instantiate,upgrade for now
	if err = e.disableJavaCCInst(cid, cis); err != nil {
		return nil, nil, nil, nil, err
	}

	//---1. check ESCC and VSCC for the chaincode
	if err = e.checkEsccAndVscc(prop); err != nil {
		return nil, nil, nil, nil, err
	}

	var cdLedger *ccprovider.ChaincodeData
	var version string

	if !syscc.IsSysCC(cid.Name) {
		cdLedger, err = e.getCDSFromLSCC(ctx, chainID, txid, signedProp, prop, cid.Name, txsim)
		if err != nil {
			return nil, nil, nil, nil, fmt.Errorf("%s - make sure the chaincode %s has been successfully instantiated and try again", err, cid.Name)
		}
		version = cdLedger.Version

		err = ccprovider.CheckInsantiationPolicy(cid.Name, version, cdLedger)
		if err != nil {
			return nil, nil, nil, nil, err
		}
	} else {
		version = util.GetSysCCVersion()
	}

	//---3. execute the proposal and get simulation results
	var simResult []byte
	var res *pb.Response
	var ccevent *pb.ChaincodeEvent
	res, ccevent, err = e.callChaincode(ctx, chainID, version, txid, signedProp, prop, cis, cid, txsim)
	if err != nil {
		endorserLogger.Errorf("failed to invoke chaincode %s on transaction %s, error: %s", cid, txid, err)
		return nil, nil, nil, nil, err
	}

	if txsim != nil {
		if simResult, err = txsim.GetTxSimulationResults(); err != nil {
			return nil, nil, nil, nil, err
		}
	}

	return cdLedger, res, simResult, ccevent, nil
}

 首先调用GetChaincodeInvocationSpec获取CIS（即ChaincodeInvocationSpec），然后调用背书中disableJavaCCInst排除java安装、实例化或升级。如果是java会直接报错。

func (e *Endorser) disableJavaCCInst(cid *pb.ChaincodeID, cis *pb.ChaincodeInvocationSpec) error {
	//if not lscc we don't care
	if cid.Name != "lscc" {
		return nil
	}

	//non-nil spec ? leave it to callers to handle error if this is an error
	if cis.ChaincodeSpec == nil || cis.ChaincodeSpec.Input == nil {
		return nil
	}

	//should at least have a command arg, leave it to callers if this is an error
	if len(cis.ChaincodeSpec.Input.Args) < 1 {
		return nil
	}

	var argNo int
	switch string(cis.ChaincodeSpec.Input.Args[0]) {
	case "install":
		argNo = 1
	case "deploy", "upgrade":
		argNo = 2
	default:
		//what else can it be ? leave it caller to handle it if error
		return nil
	}

	//the inner dep spec will contain the type
	cds, err := putils.GetChaincodeDeploymentSpec(cis.ChaincodeSpec.Input.Args[argNo])
	if err != nil {
		return err
	}

	//finally, if JAVA error out
	if cds.ChaincodeSpec.Type == pb.ChaincodeSpec_JAVA {
		return fmt.Errorf("Java chaincode is work-in-progress and disabled")
	}

	//not a java install, instantiate or upgrade op
	return nil
}

接下来执行checkEsccAndVscc，fabric 1.0直接返回nil。直接跳过

func (*Endorser) checkEsccAndVscc(prop *pb.Proposal) error {
	return nil
}

判断如果不是系统链码，调用getCDSFromLSCC，将之前获取的交易模拟器对象加入到context中。然后开始调用chaincode关于执行的代码，这里是从LSCC中获取指定名字的chaincode的数据。并通过ExecuteChaincode模拟部署链码，成功返回ccprovider.ChaincodeData对象。

func (e *Endorser) getCDSFromLSCC(ctx context.Context, chainID string, txid string, signedProp *pb.SignedProposal, prop *pb.Proposal, chaincodeID string, txsim ledger.TxSimulator) (*ccprovider.ChaincodeData, error) {
	ctxt := ctx
	if txsim != nil {
		ctxt = context.WithValue(ctx, chaincode.TXSimulatorKey, txsim)
	}

	return chaincode.GetChaincodeDataFromLSCC(ctxt, txid, signedProp, prop, chainID, chaincodeID)
}

//github.com/hyperledger/fabric/core/chaincode/chaincodeexec.go

func GetChaincodeDataFromLSCC(ctxt context.Context, txid string, signedProp *pb.SignedProposal, prop *pb.Proposal, chainID string, chaincodeID string) (*ccprovider.ChaincodeData, error) {
	version := util.GetSysCCVersion()
	cccid := ccprovider.NewCCContext(chainID, "lscc", version, txid, true, signedProp, prop)
	res, _, err := ExecuteChaincode(ctxt, cccid, [][]byte{[]byte("getccdata"), []byte(chainID), []byte(chaincodeID)})
	if err == nil {
		if res.Status != shim.OK {
			return nil, fmt.Errorf("%s", res.Message)
		}
		cd := &ccprovider.ChaincodeData{}
		err = proto.Unmarshal(res.Payload, cd)
		if err != nil {
			return nil, err
		}
		return cd, nil
	}

	return nil, err
}

调用CheckInsantiationPolicy进行实例化策略检查，通过调用callChaincode真正执行模拟安装链码，返回HTTP状态应答和执行的chaincode事件。最终通过GetTxSimulationResults获取执行chaincode的读写集。

最后一步，对模拟执行的结果进行背书签名返回。调用endorseProposal调用ESCC进行签名背书。

func (e *Endorser) endorseProposal(ctx context.Context, chainID string, txid string, signedProp *pb.SignedProposal, proposal *pb.Proposal, response *pb.Response, simRes []byte, event *pb.ChaincodeEvent, visibility []byte, ccid *pb.ChaincodeID, txsim ledger.TxSimulator, cd *ccprovider.ChaincodeData) (*pb.ProposalResponse, error) {
	endorserLogger.Debugf("Entry - txid: %s channel id: %s chaincode id: %s", txid, chainID, ccid)
	defer endorserLogger.Debugf("Exit")

	isSysCC := cd == nil
	// 1) extract the name of the escc that is requested to endorse this chaincode
	var escc string
	//ie, not "lscc" or system chaincodes
	if isSysCC {
		// FIXME: getCDSFromLSCC seems to fail for lscc - not sure this is expected?
		// TODO: who should endorse a call to LSCC?
		escc = "escc"
	} else {
		escc = cd.Escc
		if escc == "" { // this should never happen, LSCC always fills this field
			panic("No ESCC specified in ChaincodeData")
		}
	}

	endorserLogger.Debugf("info: escc for chaincode id %s is %s", ccid, escc)

	// marshalling event bytes
	var err error
	var eventBytes []byte
	if event != nil {
		eventBytes, err = putils.GetBytesChaincodeEvent(event)
		if err != nil {
			return nil, fmt.Errorf("failed to marshal event bytes - %s", err)
		}
	}

	resBytes, err := putils.GetBytesResponse(response)
	if err != nil {
		return nil, fmt.Errorf("failed to marshal response bytes - %s", err)
	}

	// set version of executing chaincode
	if isSysCC {
		// if we want to allow mixed fabric levels we should
		// set syscc version to ""
		ccid.Version = util.GetSysCCVersion()
	} else {
		ccid.Version = cd.Version
	}

	ccidBytes, err := putils.Marshal(ccid)
	if err != nil {
		return nil, fmt.Errorf("failed to marshal ChaincodeID - %s", err)
	}

	// 3) call the ESCC we've identified
	// arguments:
	// args[0] - function name (not used now)
	// args[1] - serialized Header object
	// args[2] - serialized ChaincodeProposalPayload object
	// args[3] - ChaincodeID of executing chaincode
	// args[4] - result of executing chaincode
	// args[5] - binary blob of simulation results
	// args[6] - serialized events
	// args[7] - payloadVisibility
	args := [][]byte{[]byte(""), proposal.Header, proposal.Payload, ccidBytes, resBytes, simRes, eventBytes, visibility}
	version := util.GetSysCCVersion()
	ecccis := &pb.ChaincodeInvocationSpec{ChaincodeSpec: &pb.ChaincodeSpec{Type: pb.ChaincodeSpec_GOLANG, ChaincodeId: &pb.ChaincodeID{Name: escc}, Input: &pb.ChaincodeInput{Args: args}}}
	res, _, err := e.callChaincode(ctx, chainID, version, txid, signedProp, proposal, ecccis, &pb.ChaincodeID{Name: escc}, txsim)
	if err != nil {
		return nil, err
	}

	if res.Status >= shim.ERRORTHRESHOLD {
		return &pb.ProposalResponse{Response: res}, nil
	}

	prBytes := res.Payload
	// Note that we do not extract any simulation results from
	// the call to ESCC. This is intentional becuse ESCC is meant
	// to endorse (i.e. sign) the simulation results of a chaincode,
	// but it can't obviously sign its own. Furthermore, ESCC runs
	// on private input (its own signing key) and so if it were to
	// produce simulationr results, they are likely to be different
	// from other ESCCs, which would stand in the way of the
	// endorsement process.

	//3 -- respond
	pResp, err := putils.GetProposalResponse(prBytes)
	if err != nil {
		return nil, err
	}

	return pResp, nil
}

引用:

https://blog.youkuaiyun.com/u011386109/article/details/77816513

Hperledger Fabric入门课程1 ——了解Fabric
TrueTechLabs 官方博客
11-14 1103
Hyperledger Fabric 入门课程第一节
Hperledger Fabric入门课程4 —— Fabric安装与启动
TrueTechLabs 官方博客
11-15 1634
本节简单介绍了Fabric安装的方法与启动
Hyperledger Fabric从源码分析交易
pigff的博客
05-20 1749
在上一章Hyperledger Fabric从源码分析区块结构中提到了区块的概念，并从源码角度对区块的结构进行了剖析，知道一个简单的区块包含了下面几个部分 BlockHeader， 区块头 BlockData，区块数据 BlockMetaData，区块元数据 上篇文章中已经对区块头，区块数据，区块元数据各个字段的内容进行了分析。我们知道BlockData字段是一个切片，存储的是一条条交易，但是并没有对交易具体的结构进行剖析。那么这篇文章就来分析一下一条交易里面会有哪些东西。 1. 先猜想一下一条交易会有
hyperledger fabric介绍
热门推荐
flying roc
05-08 1万+
一.Hyperledger Fabric介绍 2015年，Linux基金会启动了Hyperledger项目，目标是发展跨行业的区块链技术。 Hyperledger Fabric是Hyperledger中的一个区块链项目，包含一个账本，使用智能合约并且是一个通过所有参与者管理交易的系统。 Hyperledger Fabric 是分布式账本解决方案的平台，以模块化架构为基础，支持不同组件的可插拔。 具备以下特点 1. 高度保密性 2. 可伸缩性 3. 弹性 4. 可扩展性 二.基本概念 区块链 共享的、通过
1. Hyperledge Fabric 简介—1
hello_baby6的博客
01-26 1026
1. Hyperledge Fabric 简介 Hyperledger Fabric Hyperledger Fabric 是一个开源企业级许可分布式账本技术 (DLT) 平台，专为在企业环境中使用而设计，与其他流行的分布式账本或区块链平台相比，它提供了一些关键的差异化功能。 Fabric 具有高度模块化和可配置的架构，Fabric 支持以 Java、Go 和 Node.js 等通用编程语言编写的智能合约的分布式账本平台。 Fabric 平台也是经过许可的，这意味着与公共无许可网络不同，参与者是彼此认识的
fabric-1.0-:fabric 1.0源码分析笔记（个人用）账本存储结构+ chaincode执行流程+收集资源-源码资本
03-24
面料-1.0- fabric 1.0源码分析笔记（个人用）账本存储结构+ chaincode执行流程+收集资源
fabric-sourcecode_analysis:hyperledger fabric 1.0源码分析，源代码来自于github.comhyperledgerfabric，欢迎参与PR
03-23
同时这是一个我自己保存用来进行fabric源码分析的opensource。 能力有限，肯定会有很多地方分析错误，导致错误越来越少。 分析的原始码和心得体会都全部内嵌在原始码中间，方便边看边分析。 一个区块链爱好者，欢迎...
fabric1.0的源码
08-09
fabric源码下载不易，且行且珍惜，这是1.0的版本，有需要的话可以下载
兄弟连区块链教程 Fabric 1.0 源代码分析
03-27
兄弟连区块链教程 Fabric 1.0 源代码分析
深入解析Fabric 1.0源码：账本存储与Chaincode流程
在对给定文件信息进行分析之前，需要明确本任务要求输出的是关于“fabric-1.0-”相关的源码分析笔记中提及的IT知识点，而非分析笔记本身。文件信息包含标题、描述和标签，通过这些信息，我们可以抽取到的IT知识点...
HyperLeger Fabric学习（一）
qq_40713201的博客
05-25 2837
HyperLeger Fabric学习（一）一、HyperLeger简介1、HyperLeger简介2、Hyperledger社区组织结构3、Hyperledger顶级项目二、Hyperledger开发工具1、Linux Foundation ID2、Jira任务和进度管理3、Gerrit代码仓库和Review管理4、RocketChat在线沟通三、HyperLeger Fabric逻辑架构1、HyperLeger Fabric逻辑架构简介2、应用层逻辑架构3、底层逻辑架构4、HyperLeger Fabr
hperledger fabric 1.0 源码分析之peer chaincode instantiate
好记性不如烂笔头
08-27 1960
概述 peer chaincode instantiate命令用于对已安装(install)的链码实例化 介绍 instantiate命令定义 向命令instantiate添加flagList中的标记，分别代表， Lang：链码语言（go,nodejs等） ctor : json字符串参数(如：‘{args:[''init","a","100","b","200"]}’) name:...
超级账本 Fabric 交易提交过程剖析
yeasy的专栏
08-10 3892
Peer 启动后会在后台执行 gossip 服务，包括若干 goroutine，实现位于 gossip/state/state.go#NewGossipStateProvider(chainID string, services *ServicesMediator, ledger ledgerResources) GossipStateProvider 方法。 其中一个协程专门负责处理收到的区块...
Hyperledger Fabric 交易背书的基本工作流程详解
予衡飞翔
10-18 3558
本文内容精选自华章鲜读专栏《Hyperledger-Fabric-源代码分析与深入解读》一书第二章“架构分析”。   《Hyperledger-Fabric-源代码分析与深入解读》纸书预计出版时间：2018年9月 华章鲜读上线：2018年7月（按章更新，纸书出版前更完本书全部内容） 我们概述一个交易的请求流程。如图2-5所示。 图2-5　交易的请求流程     图字翻译： ...
Fabric 1.4源码解读 4：交易背书流程解读
LIB
03-15 778
图片不能显示时，请查看原文：https://lessisbetter.site/2019/10/29/fabric-transaction-endorser-source/ 文章目录流程交易宏观流程链码调用流程提案背书流程源码分析Proposal定义ProposalHeadergRPC定义SDK发送ProposalPeer接收ProposalPeer处理Proposal主流程preProcess ...
华为云区块链的跨云联通能力构建
NicolasLearner的博客
06-08 1160
【小宅按】区块链本质上是一种团队活动，成功源自相互的开放与协作。真实业务驱动的区块链需要多方服务提供商的参与，而且客户拥有对区块链网络的最终选择权。华为不断探索多云区块链网络的互连和互操作，与合作伙伴共同提供区块链云化解决方案和服务。­­­­ 一. 背景 为了验证华为云BCS区块链服务云上云下融合部署能力、支持跨云部署能力，以及华为云BCS服务与社区原生Fabric网络的融合部署能力，我们做了如下的部署验证，证明了方案的可行性，完成了部署并实测了invoke交易，过程中顺便验证了下Fabric1.2版本
Hyperledger fabric查询区块错误问题解决：“error Entry not found in index”
大壮的博客
04-02 4267
最近写了一个Hyperledger Fabric区块监控的程序，功能是应用程序监听区块生成事件，并查询新生成区块的信息。然而，当客户端收到Peer发来的blockEvent事件后，调用Channel对象的queryBlockByNumber()方法时，出现了“error Entry not found in index”错误。 一、错误描述 在调用queryBlockByNumber()方法时，向...
Hands-On Hyperledger Fabric——Fabric交易流程详解
No_Game_No_Life_的博客
11-14 1642
文章目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值