fabric交易解析

message ProcessedTransaction {
    // An Envelope which includes a processed transaction
    common.Envelope transactionEnvelope = 1;


    // An indication of whether the transaction was validated or invalidated by committing peer
    int32 validationCode = 2;
}

message Envelope {
    // A marshaled Payload
    bytes payload = 1;


    // A signature by the creator specified in the Payload header
    bytes signature = 2;
}

message Payload {
    // Header is included to provide identity and prevent replay
    Header header = 1;


    // Data, the encoding of which is defined by the type in the header
    bytes data = 2;
}

message Header {
    bytes channel_header = 1;
    bytes signature_header = 2;
}

message ChannelHeader {
    int32 type = 1; // Header types 0-10000 are reserved and defined by HeaderType


    // Version indicates message protocol version
    int32 version = 2;


    // Timestamp is the local time when the message was created
    // by the sender
    google.protobuf.Timestamp timestamp = 3;


    // Identifier of the channel this message is bound for
    string channel_id = 4;


    // An unique identifier that is used end-to-end.
    //  -  set by higher layers such as end user or SDK
    //  -  passed to the endorser (which will check for uniqueness)
    //  -  as the header is passed along unchanged, it will be
    //     be retrieved by the committer (uniqueness check here as well)
    //  -  to be stored in the ledger
    string tx_id = 5;


    // The epoch in which this header was generated, where epoch is defined based on block height
    // Epoch in which the response has been generated. This field identifies a
    // logical window of time. A proposal response is accepted by a peer only if
    // two conditions hold:
    // 1. the epoch specified in the message is the current epoch
    // 2. this message has been only seen once during this epoch (i.e. it hasn't
    //    been replayed)
    uint64 epoch = 6;


    // Extension that may be attached based on the header type
    bytes extension = 7;


    // If mutual TLS is employed, this represents
    // the hash of the client's TLS certificate
    bytes tls_cert_hash = 8;
}

message SignatureHeader {
    // Creator of the message, a marshaled msp.SerializedIdentity
    bytes creator = 1;


    // Arbitrary number that may only be used once. Can be used to detect replay attacks.
    bytes nonce = 2;
}

message SerializedIdentity {
    // The identifier of the associated membership service provider
    string mspid = 1;


    // the Identity, serialized according to the rules of its MPS
    bytes id_bytes = 2;
}

message Transaction {


    // The payload is an array of TransactionAction. An array is necessary to
    // accommodate multiple actions per transaction
    repeated TransactionAction actions = 1;
}


message TransactionAction {
    // The header of the proposal action, which is the proposal header
    bytes header = 1;
    
    // The payload of the action as defined by the type in the header For
    // chaincode, it's the bytes of ChaincodeActionPayload
    bytes payload = 2;
}

message ChaincodeActionPayload {
    // This field contains the bytes of the ChaincodeProposalPayload message from
    // the original invocation (essentially the arguments) after the application
    // of the visibility function. The main visibility modes are "full" (the
    // entire ChaincodeProposalPayload message is included here), "hash" (only
    // the hash of the ChaincodeProposalPayload message is included) or
    // "nothing".  This field will be used to check the consistency of
    // ProposalResponsePayload.proposalHash.  For the CHAINCODE type,
    // ProposalResponsePayload.proposalHash is supposed to be H(ProposalHeader ||
    // f(ChaincodeProposalPayload)) where f is the visibility function.
    bytes chaincode_proposal_payload = 1;


    // The list of actions to apply to the ledger
    ChaincodeEndorsedAction action = 2;
}

message ChaincodeProposalPayload {
    // Input contains the arguments for this invocation. If this invocation
    // deploys a new chaincode, ESCC/VSCC are part of this field.
    // This is usually a marshaled ChaincodeInvocationSpec
    bytes input  = 1;


    // TransientMap contains data (e.g. cryptographic material) that might be used
    // to implement some form of application-level confidentiality. The contents
    // of this field are supposed to always be omitted from the transaction and
    // excluded from the ledger.
    map<string, bytes> TransientMap = 2;
}

message ChaincodeInvocationSpec {
    // Prevent removed tag re-use
    reserved 2;
    reserved "id_generation_alg";


    ChaincodeSpec chaincode_spec = 1;
}


message ChaincodeSpec {


    enum Type {
        UNDEFINED = 0;
        GOLANG = 1;
        NODE = 2;
        CAR = 3;
        JAVA = 4;
    }


    Type type = 1;
    ChaincodeID chaincode_id = 2;
    ChaincodeInput input = 3;
    int32 timeout = 4;
}


message ChaincodeID {
    //deploy transaction will use the path
    string path = 1;


    //all other requests will use the name (really a hashcode) generated by
    //the deploy transaction
    string name = 2;


    //user friendly version name for the chaincode
    string version = 3;
}


message ChaincodeInput {
    repeated bytes args  = 1;
    map<string, bytes> decorations = 2;


    // is_init is used for the application to signal that an invocation is to be routed
    // to the legacy 'Init' function for compatibility with chaincodes which handled
    // Init in the old way.  New applications should manage their initialized state
    // themselves.
    bool is_init = 3;
}

message ChaincodeEndorsedAction {
    // This is the bytes of the ProposalResponsePayload message signed by the
    // endorsers.  Recall that for the CHAINCODE type, the
    // ProposalResponsePayload's extenstion field carries a ChaincodeAction
    bytes proposal_response_payload = 1;


    // The endorsement of the proposal, basically the endorser's signature over
    // proposalResponsePayload
    repeated Endorsement endorsements = 2;
}


message Endorsement {
    // Identity of the endorser (e.g. its certificate)
    bytes endorser = 1;


    // Signature of the payload included in ProposalResponse concatenated with
    // the endorser's certificate; ie, sign(ProposalResponse.payload + endorser)
    bytes signature = 2;
}

message ProposalResponsePayload {
    // Hash of the proposal that triggered this response. The hash is used to
    // link a response with its proposal, both for bookeeping purposes on an
    // asynchronous system and for security reasons (accountability,
    // non-repudiation). The hash usually covers the entire Proposal message
    // (byte-by-byte).
    bytes proposal_hash = 1;


    // Extension should be unmarshaled to a type-specific message. The type of
    // the extension in any proposal response depends on the type of the proposal
    // that the client selected when the proposal was initially sent out.  In
    // particular, this information is stored in the type field of a Header.  For
    // chaincode, it's a ChaincodeAction message
    bytes extension = 2;
}

message ChaincodeAction {
    reserved 5;
    reserved "token_operations";


    // This field contains the read set and the write set produced by the
    // chaincode executing this invocation.
    bytes results = 1;


    // This field contains the event generated by the chaincode.
    // Only a single marshaled ChaincodeEvent is included.
    bytes events = 2;


    // This field contains the result of executing this invocation.
    Response response = 3;


    // This field contains the ChaincodeID of executing this invocation. Endorser
    // will set it with the ChaincodeID called by endorser while simulating proposal.
    // Committer will validate the version matching with latest chaincode version.
    // Adding ChaincodeID to keep version opens up the possibility of multiple
    // ChaincodeAction per transaction.
    ChaincodeID chaincode_id = 4;
}


message Response {
    // A status code that should follow the HTTP status codes.
    int32 status = 1;


    // A message associated with the response code.
    string message = 2;


    // A payload that can be used to include metadata with this response.
    bytes payload = 3;
}

message TxReadWriteSet {
    enum DataModel {
        KV = 0;
    }
    DataModel data_model = 1;
    repeated NsReadWriteSet ns_rwset = 2;
}


message NsReadWriteSet {
   string namespace = 1;
   bytes rwset = 2;  Data model specific serialized proto message (e.g., kvrwset.KVRWSet for KV and Document data models)
   repeated CollectionHashedReadWriteSet collection_hashed_rwset = 3;
}


message CollectionHashedReadWriteSet {
    string collection_name = 1;
    bytes hashed_rwset = 2;  Data model specific serialized proto message (e.g., kvrwset.HashedRWSet for KV and Document data models)
    bytes pvt_rwset_hash = 3;  Hash of entire private read-write set for a specific collection. This helps in authenticating the private read-write set efficiently
}

message KVRWSet {
    repeated KVRead reads = 1;
    repeated RangeQueryInfo range_queries_info = 2;
    repeated KVWrite writes = 3;
    repeated KVMetadataWrite metadata_writes = 4;
}


message KVRead {
    string key = 1;
    Version version = 2;
}


message KVWrite {
    string key = 1;
    bool is_delete = 2;
    bytes value = 3;
}


message KVMetadataWrite {
    string key = 1;
    repeated KVMetadataEntry entries = 2;
}


message RangeQueryInfo {
    string start_key = 1;
    string end_key = 2;
    bool itr_exhausted = 3;
    oneof reads_info {
        QueryReads raw_reads = 4;
        QueryReadsMerkleSummary reads_merkle_hashes = 5;
    }
}


message QueryReads {
    repeated KVRead kv_reads = 1;
}