zkverifyjs/dist/esm/utils/transactions/events/index.js

Submit proofs to zkVerify and query proof state with ease using our npm package.

import { TransactionType, ZkVerifyEvents } from '../../../enums.js';
import { getProofPallet, safeEmit } from '../../helpers/index.js';
export const handleTransactionEvents = (api, events, transactionInfo, emitter, transactionType) => {
    let statementHash;
    let aggregationId;
    let statement;
    let domainId;
    let domainState;
    let receipt;
    let myExtrinsicIndex;
    const expectedPallet = transactionType === TransactionType.Verify ||
        transactionType === TransactionType.VKRegistration
        ? getProofPallet(transactionInfo.proofType)
        : undefined;
    events.forEach(({ event, phase }) => {
        if (phase.isApplyExtrinsic && myExtrinsicIndex === undefined) {
            myExtrinsicIndex = phase.asApplyExtrinsic.toNumber();
            transactionInfo.extrinsicIndex = myExtrinsicIndex;
        }
        if (!phase.isApplyExtrinsic ||
            phase.asApplyExtrinsic.toNumber() !== transactionInfo.extrinsicIndex) {
            return;
        }
        if (event.section === 'transactionPayment' &&
            event.method === 'TransactionFeePaid') {
            transactionInfo.feeInfo = {
                payer: event.data[0].toString(),
                actualFee: event.data[1].toString(),
                tip: event.data[2].toString(),
                paysFee: 'Yes',
            };
        }
        if (event.section === 'system' && event.method === 'ExtrinsicSuccess') {
            const dispatchInfo = event.data[0];
            transactionInfo.weightInfo = {
                refTime: dispatchInfo.weight.refTime?.toString(),
                proofSize: dispatchInfo.weight.proofSize?.toString(),
            };
            transactionInfo.txClass = dispatchInfo.class.toString();
            if (transactionInfo.feeInfo) {
                transactionInfo.feeInfo.paysFee = dispatchInfo.paysFee.toString();
            }
        }
        if (event.section === 'system' && event.method === 'ExtrinsicFailed') {
            const [dispatchError] = event.data;
            throw dispatchError;
        }
        if (transactionType === TransactionType.Verify &&
            event.section === expectedPallet &&
            event.method === 'ProofVerified') {
            statement = event.data[0].toString();
            safeEmit(emitter, ZkVerifyEvents.ProofVerified, { statement });
        }
        if (transactionType === TransactionType.Verify &&
            event.section === 'aggregate' &&
            event.method === 'NewProof') {
            const [eventStatement, eventDomainId, eventAggregationId] = event.data;
            statement = eventStatement.toString();
            domainId = Number(eventDomainId.toString());
            aggregationId = Number(eventAggregationId.toString());
            safeEmit(emitter, ZkVerifyEvents.NewProof, {
                statement,
                domainId,
                aggregationId,
            });
        }
        if (transactionType === TransactionType.VKRegistration &&
            event.section === expectedPallet &&
            event.method === 'VkRegistered') {
            statementHash = event.data[0].toString();
            safeEmit(emitter, ZkVerifyEvents.VkRegistered, { statementHash });
        }
        if ((transactionType === TransactionType.DomainHold ||
            transactionType === TransactionType.DomainUnregister ||
            transactionType === TransactionType.DomainRemoveSubmitters) &&
            event.section === 'aggregate' &&
            event.method === 'DomainStateChanged') {
            const [eventDomainId, state] = event.data;
            domainId = Number(eventDomainId.toString());
            domainState = state.toString();
            safeEmit(emitter, ZkVerifyEvents.DomainStateChanged, {
                domainId,
                domainState,
            });
        }
        if (transactionType === TransactionType.DomainRegistration &&
            event.section === 'aggregate' &&
            event.method === 'NewDomain') {
            domainId = Number(event.data[0].toString());
            safeEmit(emitter, ZkVerifyEvents.NewDomain, { domainId });
        }
        if (transactionType === TransactionType.Aggregate &&
            event.section === 'aggregate' &&
            event.method === 'NewAggregationReceipt') {
            const [eventDomainId, eventAggregationId, eventReceipt] = event.data;
            domainId = Number(eventDomainId.toString());
            aggregationId = Number(eventAggregationId.toString());
            receipt = eventReceipt.toString();
            safeEmit(emitter, ZkVerifyEvents.NewAggregationReceipt, {
                domainId,
                aggregationId,
                receipt,
            });
        }
    });
    switch (transactionType) {
        case TransactionType.Aggregate:
            return {
                ...transactionInfo,
                domainId,
                aggregationId,
                receipt,
            };
        case TransactionType.DomainRegistration:
            return {
                ...transactionInfo,
                domainId,
            };
        case TransactionType.DomainHold:
        case TransactionType.DomainUnregister:
        case TransactionType.DomainRemoveSubmitters:
            return {
                ...transactionInfo,
                domainId,
                domainState,
            };
        case TransactionType.DomainAddSubmitters:
            return {
                ...transactionInfo,
            };
        case TransactionType.Verify:
            return {
                ...transactionInfo,
                statement,
                domainId,
                aggregationId,
            };
        case TransactionType.VKRegistration:
        default:
            return {
                ...transactionInfo,
                statementHash,
            };
    }
};
//# sourceMappingURL=index.js.map