zkverifyjs/dist/esm/api/domain/index.js

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

import { RuntimeVersion, TransactionType, ZkVerifyEvents, } from '../../enums.js';
import { getKeyringAccountIfAvailable, isVersionAtLeast, requireVersionAtLeast, } from '../../utils/helpers/index.js';
import EventEmitter from 'events';
import { handleTransaction } from '../../utils/transactions/index.js';
export const registerDomain = (connection, aggregationSize, queueSize = 16, domainOptions, signerAccount) => {
    if (aggregationSize <= 0 || aggregationSize > 128)
        throw new Error(`registerDomain aggregationSize must be between 1 and 128`);
    if (queueSize <= 0 || queueSize > 16)
        throw new Error(`registerDomain queueSize must be between 1 and 16`);
    if (domainOptions.aggregateRules === undefined)
        throw new Error(`registerDomain deliveryOptions.aggregateRules must be defined`);
    const delivery = { None: null };
    const { api, runtimeSpec } = connection;
    const isV1_3_0OrLater = isVersionAtLeast(runtimeSpec, RuntimeVersion.V1_3_0);
    if (isV1_3_0OrLater && !domainOptions.proofSecurityRules) {
        throw new Error(`registerDomain proofSecurityRules is required for runtime version 1.3.0 or later`);
    }
    const registerExtrinsic = isV1_3_0OrLater
        ? api.tx.aggregate.registerDomain(aggregationSize, queueSize, domainOptions.aggregateRules, domainOptions.proofSecurityRules, delivery, domainOptions.deliveryOwner)
        : api.tx.aggregate.registerDomain(aggregationSize, queueSize, domainOptions.aggregateRules, delivery, domainOptions.deliveryOwner);
    const emitter = new EventEmitter();
    const transactionResult = performTransaction(connection, registerExtrinsic, TransactionType.DomainRegistration, emitter, signerAccount);
    return { events: emitter, transactionResult };
};
export const holdDomain = (connection, domainId, signerAccount) => {
    if (domainId < 0)
        throw new Error(`holdDomain domainId must be greater than 0`);
    const holdExtrinsic = connection.api.tx.aggregate.holdDomain(domainId);
    const emitter = new EventEmitter();
    const transactionResult = performTransaction(connection, holdExtrinsic, TransactionType.DomainHold, emitter, signerAccount);
    return { events: emitter, transactionResult };
};
export const unregisterDomain = (connection, domainId, signerAccount) => {
    if (domainId < 0)
        throw new Error(`unregisterDomain domainId must be greater than 0`);
    const unregisterExtrinsic = connection.api.tx.aggregate.unregisterDomain(domainId);
    const emitter = new EventEmitter();
    const transactionResult = performTransaction(connection, unregisterExtrinsic, TransactionType.DomainUnregister, emitter, signerAccount);
    return { events: emitter, transactionResult };
};
export const aggregate = (connection, domainId, aggregationId, signerAccount) => {
    const registerExtrinsic = connection.api.tx.aggregate.aggregate(domainId, aggregationId);
    const emitter = new EventEmitter();
    const transactionResult = performTransaction(connection, registerExtrinsic, TransactionType.Aggregate, emitter, signerAccount);
    return { events: emitter, transactionResult };
};
export const addDomainSubmitters = (connection, domainId, submitters, signerAccount) => {
    if (domainId < 0)
        throw new Error(`addDomainSubmitters domainId must be greater than 0`);
    if (!submitters || submitters.length === 0)
        throw new Error(`addDomainSubmitters submitters must not be empty`);
    const { api, runtimeSpec } = connection;
    requireVersionAtLeast(runtimeSpec, RuntimeVersion.V1_3_0, 'addDomainSubmitters');
    const allowlistExtrinsic = api.tx.aggregate.allowlistProofSubmitters(domainId, submitters);
    const emitter = new EventEmitter();
    const transactionResult = performTransaction(connection, allowlistExtrinsic, TransactionType.DomainAddSubmitters, emitter, signerAccount);
    return { events: emitter, transactionResult };
};
export const removeDomainSubmitters = (connection, domainId, submitters, signerAccount) => {
    if (domainId < 0)
        throw new Error(`removeDomainSubmitters domainId must be greater than 0`);
    if (!submitters || submitters.length === 0)
        throw new Error(`removeDomainSubmitters submitters must not be empty`);
    const { api, runtimeSpec } = connection;
    requireVersionAtLeast(runtimeSpec, RuntimeVersion.V1_3_0, 'removeDomainSubmitters');
    const removeExtrinsic = api.tx.aggregate.removeProofSubmitters(domainId, submitters);
    const emitter = new EventEmitter();
    const transactionResult = performTransaction(connection, removeExtrinsic, TransactionType.DomainRemoveSubmitters, emitter, signerAccount);
    return { events: emitter, transactionResult };
};
export const performTransaction = async (connection, extrinsic, transactionType, emitter, signerAccount) => {
    const { api } = connection;
    const selectedAccount = getKeyringAccountIfAvailable(connection, signerAccount);
    try {
        const result = await (async () => {
            if (selectedAccount) {
                return await handleTransaction(api, extrinsic, selectedAccount, undefined, emitter, {}, transactionType);
            }
            else if ('injector' in connection) {
                const { signer } = connection.injector;
                return await handleTransaction(api, extrinsic, connection.accountAddress, signer, emitter, {}, transactionType);
            }
            else {
                throw new Error('Unsupported connection type.');
            }
        })();
        emitter.removeAllListeners();
        return result;
    }
    catch (error) {
        emitter.emit(ZkVerifyEvents.ErrorEvent, error);
        emitter.removeAllListeners();
        throw error;
    }
};
//# sourceMappingURL=index.js.map