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, normalizeDeliveryFromOptions, 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 = normalizeDeliveryFromOptions(domainOptions);
  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;
  }
};