private void populateChannelHeader() {
    Header header = null;
    if(_header != null) {
        header = _header.get();
    }
    if(null == header) {
        populateHeader();
        header = _header.get();
    }
    ChannelHeader channelHeader;
    try {
        channelHeader = ChannelHeader.parseFrom(header.getChannelHeader());
    } catch (InvalidProtocolBufferException e) {
        throw new BlkchnException("Error creating object from ByteString", e);
    }
    _channelHeader = new WeakReference<>(channelHeader);
}
 

static EnvelopeDeserializer newInstance(ByteString byteString, byte b) throws InvalidProtocolBufferException {
    EnvelopeDeserializer ret;
    final int type = ChannelHeader.parseFrom(Payload.parseFrom(Envelope.parseFrom(byteString).getPayload())
            .getHeader().getChannelHeader()).getType();
   /*
MESSAGE = 0;                   // Used for messages which are signed but opaque
CONFIG = 1;                    // Used for messages which express the channel config
CONFIG_UPDATE = 2;             // Used for transactions which update the channel config
ENDORSER_TRANSACTION = 3;      // Used by the SDK to submit endorser based transactions
ORDERER_TRANSACTION = 4;       // Used internally by the orderer for management
DELIVER_SEEK_INFO = 5;         // Used as the type for Envelope messages submitted to instruct the Deliver API to seek
CHAINCODE_PACKAGE = 6;         // Used for packaging chaincode artifacts for install
 */

    switch (type) {
        case 3:
            ret = new EndorserTransactionEnvDeserializer(byteString, b);
            break;
        default: //just assume base properties.
            ret = new EnvelopeDeserializer(byteString, b);
            break;
    }
    return ret;
}
 

ChannelHeader getChannelHeader() {
    ChannelHeader ret = null;

    if (channelHeader != null) {
        ret = channelHeader.get();

    }
    if (null == ret) {
        try {
            ret = ChannelHeader.parseFrom(byteString);
        } catch (InvalidProtocolBufferException e) {
            throw new InvalidProtocolBufferRuntimeException(e);
        }
        channelHeader = new WeakReference<>(ret);

    }

    return ret;

}
 

/**
 *
 * @param message
 * @param handler
 * @throws InvalidProtocolBufferException
 */
InvocationStubImpl(final ChaincodeMessage message, final ChaincodeInvocationTask handler)
        throws InvalidProtocolBufferException {
    this.channelId = message.getChannelId();
    this.txId = message.getTxid();
    this.handler = handler;
    final ChaincodeInput input = ChaincodeInput.parseFrom(message.getPayload());

    this.args = Collections.unmodifiableList(input.getArgsList());
    this.signedProposal = message.getProposal();
    if (this.signedProposal == null || this.signedProposal.getProposalBytes().isEmpty()) {
        this.creator = null;
        this.txTimestamp = null;
        this.transientMap = Collections.emptyMap();
        this.binding = null;
    } else {
        try {
            final Proposal proposal = Proposal.parseFrom(signedProposal.getProposalBytes());
            final Header header = Header.parseFrom(proposal.getHeader());
            final ChannelHeader channelHeader = ChannelHeader.parseFrom(header.getChannelHeader());
            validateProposalType(channelHeader);
            final SignatureHeader signatureHeader = SignatureHeader.parseFrom(header.getSignatureHeader());
            final ChaincodeProposalPayload chaincodeProposalPayload = ChaincodeProposalPayload
                    .parseFrom(proposal.getPayload());
            final Timestamp timestamp = channelHeader.getTimestamp();

            this.txTimestamp = Instant.ofEpochSecond(timestamp.getSeconds(), timestamp.getNanos());
            this.creator = signatureHeader.getCreator();
            this.transientMap = chaincodeProposalPayload.getTransientMapMap();
            this.binding = computeBinding(channelHeader, signatureHeader);
        } catch (InvalidProtocolBufferException | NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
}
 

private byte[] computeBinding(final ChannelHeader channelHeader, final SignatureHeader signatureHeader)
        throws NoSuchAlgorithmException {
    final MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
    messageDigest.update(signatureHeader.getNonce().asReadOnlyByteBuffer());
    messageDigest.update(this.creator.asReadOnlyByteBuffer());
    final ByteBuffer epochBytes = ByteBuffer.allocate(Long.BYTES).order(ByteOrder.LITTLE_ENDIAN)
            .putLong(channelHeader.getEpoch());
    epochBytes.flip();
    messageDigest.update(epochBytes);
    return messageDigest.digest();
}
 

private void validateProposalType(final ChannelHeader channelHeader) {
    switch (Common.HeaderType.forNumber(channelHeader.getType())) {
    case ENDORSER_TRANSACTION:
    case CONFIG:
        return;
    default:
        throw new RuntimeException(
                String.format("Unexpected transaction type: %s", HeaderType.forNumber(channelHeader.getType())));
    }
}