@siglesiasg/node-red-hyperledger-fabric-gateway/dist/libs/fabric-parse-block.js

Hyperledger Fabric 2.x nodes for node-red with latest fabric-gateway library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseBlock = void 0;
const gateway_1 = require("@hyperledger/fabric-gateway/dist/gateway");
const fabric_protos_1 = require("@hyperledger/fabric-protos");
function parseBlock(block) {
    const validationCodes = getTransactionValidationCodes(block);
    const header = (0, gateway_1.assertDefined)(block.getHeader(), 'Missing block header');
    return {
        getNumber: () => BigInt(header.getNumber()),
        getHash: () => header.getDataHash_asB64(),
        getTransactions: cache(() => getPayloads(block)
            .map((payload, i) => parsePayload(payload, validationCodes[i]))
            .filter(payload => payload.isEndorserTransaction())
            .map(newTransaction)),
        toProto: () => block,
    };
}
exports.parseBlock = parseBlock;
function parsePayload(payload, statusCode) {
    const cachedChannelHeader = cache(() => getChannelHeader(payload));
    const isEndorserTransaction = () => cachedChannelHeader().getType() === fabric_protos_1.common.HeaderType.ENDORSER_TRANSACTION;
    return {
        getChannelHeader: cachedChannelHeader,
        getEndorserTransaction: () => {
            if (!isEndorserTransaction()) {
                throw new Error(`Unexpected payload type: ${cachedChannelHeader().getType()}`);
            }
            const transaction = fabric_protos_1.peer.Transaction.deserializeBinary(payload.getData_asU8());
            return parseEndorserTransaction(transaction);
        },
        getSignatureHeader: cache(() => getSignatureHeader(payload)),
        getTransactionValidationCode: () => statusCode,
        isEndorserTransaction,
        isValid: () => statusCode === fabric_protos_1.peer.TxValidationCode.VALID,
        toProto: () => payload,
    };
}
function parseEndorserTransaction(transaction) {
    return {
        getReadWriteSets: cache(() => getChaincodeActionPayloads(transaction)
            .map(payload => (0, gateway_1.assertDefined)(payload.getAction(), 'Missing chaincode endorsed action'))
            .map(endorsedAction => endorsedAction.getProposalResponsePayload_asU8())
            .map(bytes => fabric_protos_1.peer.ProposalResponsePayload.deserializeBinary(bytes))
            .map(responsePayload => fabric_protos_1.peer.ChaincodeAction.deserializeBinary(responsePayload.getExtension_asU8()))
            .map(chaincodeAction => chaincodeAction.getResults_asU8())
            .map(bytes => fabric_protos_1.ledger.rwset.TxReadWriteSet.deserializeBinary(bytes))
            .map(parseReadWriteSet)),
        toProto: () => transaction,
    };
}
function newTransaction(payload) {
    const transaction = payload.getEndorserTransaction();
    return {
        getChannelHeader: () => payload.getChannelHeader(),
        getCreator: () => {
            const creatorBytes = payload.getSignatureHeader().getCreator_asU8();
            const creator = fabric_protos_1.msp.SerializedIdentity.deserializeBinary(creatorBytes);
            return {
                mspId: creator.getMspid(),
                credentials: creator.getIdBytes_asU8(),
            };
        },
        getNamespaceReadWriteSets: () => transaction.getReadWriteSets().flatMap(readWriteSet => readWriteSet.getNamespaceReadWriteSets()),
        getValidationCode: () => payload.getTransactionValidationCode(),
        isValid: () => payload.isValid(),
        toProto: () => payload.toProto(),
    };
}
function parseReadWriteSet(readWriteSet) {
    return {
        getNamespaceReadWriteSets: () => {
            if (readWriteSet.getDataModel() !== fabric_protos_1.ledger.rwset.TxReadWriteSet.DataModel.KV) {
                throw new Error(`Unexpected read/write set data model: ${readWriteSet.getDataModel()}`);
            }
            return readWriteSet.getNsRwsetList().map(parseNamespaceReadWriteSet);
        },
        toProto: () => readWriteSet,
    };
}
function parseNamespaceReadWriteSet(nsReadWriteSet) {
    return {
        getNamespace: () => nsReadWriteSet.getNamespace(),
        getReadWriteSet: cache(() => fabric_protos_1.ledger.rwset.kvrwset.KVRWSet.deserializeBinary(nsReadWriteSet.getRwset_asU8())),
        toProto: () => nsReadWriteSet,
    };
}
function getTransactionValidationCodes(block) {
    const metadata = (0, gateway_1.assertDefined)(block.getMetadata(), 'Missing block metadata');
    return metadata.getMetadataList_asU8()[fabric_protos_1.common.BlockMetadataIndex.TRANSACTIONS_FILTER];
}
function getPayloads(block) {
    return (block.getData()?.getDataList_asU8() ?? [])
        .map(bytes => fabric_protos_1.common.Envelope.deserializeBinary(bytes))
        .map(envelope => envelope.getPayload_asU8())
        .map(bytes => fabric_protos_1.common.Payload.deserializeBinary(bytes));
}
function getChannelHeader(payload) {
    const header = (0, gateway_1.assertDefined)(payload.getHeader(), 'Missing payload header');
    return fabric_protos_1.common.ChannelHeader.deserializeBinary(header.getChannelHeader_asU8());
}
function getSignatureHeader(payload) {
    const header = (0, gateway_1.assertDefined)(payload.getHeader(), 'Missing payload header');
    return fabric_protos_1.common.SignatureHeader.deserializeBinary(header.getSignatureHeader_asU8());
}
function getChaincodeActionPayloads(transaction) {
    return transaction.getActionsList()
        .map(transactionAction => transactionAction.getPayload_asU8())
        .map(bytes => fabric_protos_1.peer.ChaincodeActionPayload.deserializeBinary(bytes));
}
function cache(f) {
    let value;
    return () => {
        if (value === undefined) {
            value = f();
        }
        return value;
    };
}
//# sourceMappingURL=fabric-parse-block.js.map