github.com/lzy4123/fabric@v2.1.1+incompatible/protoutil/unmarshalers.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package protoutil
     8  
     9  import (
    10  	"github.com/golang/protobuf/proto"
    11  	"github.com/hyperledger/fabric-protos-go/common"
    12  	cb "github.com/hyperledger/fabric-protos-go/common"
    13  	"github.com/hyperledger/fabric-protos-go/msp"
    14  	"github.com/hyperledger/fabric-protos-go/peer"
    15  	pb "github.com/hyperledger/fabric-protos-go/peer"
    16  	"github.com/pkg/errors"
    17  )
    18  
    19  // the implicit contract of all these unmarshalers is that they
    20  // will return a non-nil pointer whenever the error is nil
    21  
    22  // UnmarshalBlock unmarshals bytes to a Block
    23  func UnmarshalBlock(encoded []byte) (*cb.Block, error) {
    24  	block := &cb.Block{}
    25  	err := proto.Unmarshal(encoded, block)
    26  	return block, errors.Wrap(err, "error unmarshaling Block")
    27  }
    28  
    29  // UnmarshalChaincodeDeploymentSpec unmarshals bytes to a ChaincodeDeploymentSpec
    30  func UnmarshalChaincodeDeploymentSpec(code []byte) (*peer.ChaincodeDeploymentSpec, error) {
    31  	cds := &peer.ChaincodeDeploymentSpec{}
    32  	err := proto.Unmarshal(code, cds)
    33  	return cds, errors.Wrap(err, "error unmarshaling ChaincodeDeploymentSpec")
    34  }
    35  
    36  // UnmarshalChaincodeInvocationSpec unmarshals bytes to a ChaincodeInvocationSpec
    37  func UnmarshalChaincodeInvocationSpec(encoded []byte) (*peer.ChaincodeInvocationSpec, error) {
    38  	cis := &peer.ChaincodeInvocationSpec{}
    39  	err := proto.Unmarshal(encoded, cis)
    40  	return cis, errors.Wrap(err, "error unmarshaling ChaincodeInvocationSpec")
    41  }
    42  
    43  // UnmarshalPayload unmarshals bytes to a Payload
    44  func UnmarshalPayload(encoded []byte) (*cb.Payload, error) {
    45  	payload := &cb.Payload{}
    46  	err := proto.Unmarshal(encoded, payload)
    47  	return payload, errors.Wrap(err, "error unmarshaling Payload")
    48  }
    49  
    50  // UnmarshalEnvelope unmarshals bytes to a Envelope
    51  func UnmarshalEnvelope(encoded []byte) (*cb.Envelope, error) {
    52  	envelope := &cb.Envelope{}
    53  	err := proto.Unmarshal(encoded, envelope)
    54  	return envelope, errors.Wrap(err, "error unmarshaling Envelope")
    55  }
    56  
    57  // UnmarshalChannelHeader unmarshals bytes to a ChannelHeader
    58  func UnmarshalChannelHeader(bytes []byte) (*cb.ChannelHeader, error) {
    59  	chdr := &cb.ChannelHeader{}
    60  	err := proto.Unmarshal(bytes, chdr)
    61  	return chdr, errors.Wrap(err, "error unmarshaling ChannelHeader")
    62  }
    63  
    64  // UnmarshalChaincodeID unmarshals bytes to a ChaincodeID
    65  func UnmarshalChaincodeID(bytes []byte) (*peer.ChaincodeID, error) {
    66  	ccid := &pb.ChaincodeID{}
    67  	err := proto.Unmarshal(bytes, ccid)
    68  	return ccid, errors.Wrap(err, "error unmarshaling ChaincodeID")
    69  }
    70  
    71  // UnmarshalSignatureHeader unmarshals bytes to a SignatureHeader
    72  func UnmarshalSignatureHeader(bytes []byte) (*cb.SignatureHeader, error) {
    73  	sh := &common.SignatureHeader{}
    74  	err := proto.Unmarshal(bytes, sh)
    75  	return sh, errors.Wrap(err, "error unmarshaling SignatureHeader")
    76  }
    77  
    78  func UnmarshalSerializedIdentity(bytes []byte) (*msp.SerializedIdentity, error) {
    79  	sid := &msp.SerializedIdentity{}
    80  	err := proto.Unmarshal(bytes, sid)
    81  	return sid, errors.Wrap(err, "error unmarshaling SerializedIdentity")
    82  }
    83  
    84  // UnmarshalHeader unmarshals bytes to a Header
    85  func UnmarshalHeader(bytes []byte) (*common.Header, error) {
    86  	hdr := &common.Header{}
    87  	err := proto.Unmarshal(bytes, hdr)
    88  	return hdr, errors.Wrap(err, "error unmarshaling Header")
    89  }
    90  
    91  // UnmarshalChaincodeHeaderExtension unmarshals bytes to a ChaincodeHeaderExtension
    92  func UnmarshalChaincodeHeaderExtension(hdrExtension []byte) (*peer.ChaincodeHeaderExtension, error) {
    93  	chaincodeHdrExt := &peer.ChaincodeHeaderExtension{}
    94  	err := proto.Unmarshal(hdrExtension, chaincodeHdrExt)
    95  	return chaincodeHdrExt, errors.Wrap(err, "error unmarshaling ChaincodeHeaderExtension")
    96  }
    97  
    98  // UnmarshalProposalResponse unmarshals bytes to a ProposalResponse
    99  func UnmarshalProposalResponse(prBytes []byte) (*peer.ProposalResponse, error) {
   100  	proposalResponse := &peer.ProposalResponse{}
   101  	err := proto.Unmarshal(prBytes, proposalResponse)
   102  	return proposalResponse, errors.Wrap(err, "error unmarshaling ProposalResponse")
   103  }
   104  
   105  // UnmarshalChaincodeAction unmarshals bytes to a ChaincodeAction
   106  func UnmarshalChaincodeAction(caBytes []byte) (*peer.ChaincodeAction, error) {
   107  	chaincodeAction := &peer.ChaincodeAction{}
   108  	err := proto.Unmarshal(caBytes, chaincodeAction)
   109  	return chaincodeAction, errors.Wrap(err, "error unmarshaling ChaincodeAction")
   110  }
   111  
   112  // UnmarshalResponse unmarshals bytes to a Response
   113  func UnmarshalResponse(resBytes []byte) (*peer.Response, error) {
   114  	response := &peer.Response{}
   115  	err := proto.Unmarshal(resBytes, response)
   116  	return response, errors.Wrap(err, "error unmarshaling Response")
   117  }
   118  
   119  // UnmarshalChaincodeEvents unmarshals bytes to a ChaincodeEvent
   120  func UnmarshalChaincodeEvents(eBytes []byte) (*peer.ChaincodeEvent, error) {
   121  	chaincodeEvent := &peer.ChaincodeEvent{}
   122  	err := proto.Unmarshal(eBytes, chaincodeEvent)
   123  	return chaincodeEvent, errors.Wrap(err, "error unmarshaling ChaicnodeEvent")
   124  }
   125  
   126  // UnmarshalProposalResponsePayload unmarshals bytes to a ProposalResponsePayload
   127  func UnmarshalProposalResponsePayload(prpBytes []byte) (*peer.ProposalResponsePayload, error) {
   128  	prp := &peer.ProposalResponsePayload{}
   129  	err := proto.Unmarshal(prpBytes, prp)
   130  	return prp, errors.Wrap(err, "error unmarshaling ProposalResponsePayload")
   131  }
   132  
   133  // UnmarshalProposal unmarshals bytes to a Proposal
   134  func UnmarshalProposal(propBytes []byte) (*peer.Proposal, error) {
   135  	prop := &peer.Proposal{}
   136  	err := proto.Unmarshal(propBytes, prop)
   137  	return prop, errors.Wrap(err, "error unmarshaling Proposal")
   138  }
   139  
   140  // UnmarshalTransaction unmarshals bytes to a Transaction
   141  func UnmarshalTransaction(txBytes []byte) (*peer.Transaction, error) {
   142  	tx := &peer.Transaction{}
   143  	err := proto.Unmarshal(txBytes, tx)
   144  	return tx, errors.Wrap(err, "error unmarshaling Transaction")
   145  }
   146  
   147  // UnmarshalChaincodeActionPayload unmarshals bytes to a ChaincodeActionPayload
   148  func UnmarshalChaincodeActionPayload(capBytes []byte) (*peer.ChaincodeActionPayload, error) {
   149  	cap := &peer.ChaincodeActionPayload{}
   150  	err := proto.Unmarshal(capBytes, cap)
   151  	return cap, errors.Wrap(err, "error unmarshaling ChaincodeActionPayload")
   152  }
   153  
   154  // UnmarshalChaincodeProposalPayload unmarshals bytes to a ChaincodeProposalPayload
   155  func UnmarshalChaincodeProposalPayload(bytes []byte) (*peer.ChaincodeProposalPayload, error) {
   156  	cpp := &peer.ChaincodeProposalPayload{}
   157  	err := proto.Unmarshal(bytes, cpp)
   158  	return cpp, errors.Wrap(err, "error unmarshaling ChaincodeProposalPayload")
   159  }
   160  
   161  // UnmarshalPayloadOrPanic unmarshals bytes to a Payload structure or panics
   162  // on error
   163  func UnmarshalPayloadOrPanic(encoded []byte) *cb.Payload {
   164  	payload, err := UnmarshalPayload(encoded)
   165  	if err != nil {
   166  		panic(err)
   167  	}
   168  	return payload
   169  }
   170  
   171  // UnmarshalEnvelopeOrPanic unmarshals bytes to an Envelope structure or panics
   172  // on error
   173  func UnmarshalEnvelopeOrPanic(encoded []byte) *cb.Envelope {
   174  	envelope, err := UnmarshalEnvelope(encoded)
   175  	if err != nil {
   176  		panic(err)
   177  	}
   178  	return envelope
   179  }
   180  
   181  // UnmarshalBlockOrPanic unmarshals bytes to an Block or panics
   182  // on error
   183  func UnmarshalBlockOrPanic(encoded []byte) *cb.Block {
   184  	block, err := UnmarshalBlock(encoded)
   185  	if err != nil {
   186  		panic(err)
   187  	}
   188  	return block
   189  }
   190  
   191  // UnmarshalChannelHeaderOrPanic unmarshals bytes to a ChannelHeader or panics
   192  // on error
   193  func UnmarshalChannelHeaderOrPanic(bytes []byte) *cb.ChannelHeader {
   194  	chdr, err := UnmarshalChannelHeader(bytes)
   195  	if err != nil {
   196  		panic(err)
   197  	}
   198  	return chdr
   199  }
   200  
   201  // UnmarshalSignatureHeaderOrPanic unmarshals bytes to a SignatureHeader or panics
   202  // on error
   203  func UnmarshalSignatureHeaderOrPanic(bytes []byte) *cb.SignatureHeader {
   204  	sighdr, err := UnmarshalSignatureHeader(bytes)
   205  	if err != nil {
   206  		panic(err)
   207  	}
   208  	return sighdr
   209  }