@devtion/actions/src/types/index.ts

A set of actions and helpers for CLI commands

import { FirebaseApp } from "firebase/app"
import { DocumentReference, DocumentData, Firestore } from "firebase/firestore"
import { Functions } from "firebase/functions"
import {
    CeremonyState,
    CeremonyTimeoutType,
    CeremonyType,
    CircuitContributionVerificationMechanism,
    DiskTypeForVM,
    ParticipantContributionStep,
    ParticipantStatus
} from "./enums.js"

/**
 * A shared type that groups all the AWS services variables.
 * @typedef {Object} AWSVariables
 * @property {string} accessKeyId - the key identifier related to S3 APIs.
 * @property {string} secretAccessKey - the secret access key related to S3 APIs.
 * @property {string} region - the region where your buckets are located.
 * @property {string} instanceProfileArn - the EC2 instance profile the VM should use to access S3.
 * @property {string} amiId - the AWS AMI ID (default to Amazon Linux 2).
 */
export type AWSVariables = {
    accessKeyId: string
    secretAccessKey: string
    region: string
    instanceProfileArn: string
    amiId: string
}

/**
 * A shared type that groups all the Firebase services used in the application context.
 * @typedef {Object} FirebaseServices
 * @property {FirebaseApp} firebaseApp - the instance of the Firebase application.
 * @property {Firestore} firestoreDatabase - the instance of the Firestore database in use for the application.
 * @property {Functions} firebaseFunctions - the instance of the Cloud Functions in use for the application.
 */
export type FirebaseServices = {
    firebaseApp: FirebaseApp
    firestoreDatabase: Firestore
    firebaseFunctions: Functions
}

/**
 * Useful for interacting with reference and data from a Firestore document at the same time.
 * @typedef {Object} FirebaseDocumentInfo
 * @property {string} id - the unique identifier of the Firestore document.
 * @property {DocumentReference<DocumentData>} ref - the Firestore reference for the document (useful for queries).
 * @property {DocumentData} data - the Firestore document whole data.
 */
export type FirebaseDocumentInfo = {
    id: string
    ref: DocumentReference<DocumentData>
    data: DocumentData
}

/**
 * Define a custom file data chunk associated with a pre-signed url.
 * @dev Useful when interacting with AWS S3 buckets using pre-signed urls for multi-part upload or download storing temporary information on the database.
 * @typedef {Object} ChunkWithUrl
 * @property {number} partNumber - indicate where the chunk is positioned in order to reconhstruct the file with multiPartUpload/Download.
 * @property {Buffer} chunk - the piece of information in bytes.
 * @property {string} preSignedUrl - the unique reference to the pre-signed url to which this chunk is linked too.
 */
export type ChunkWithUrl = {
    partNumber: number
    chunk: Buffer
    preSignedUrl: string
}

/**
 * Group a pre-signed url chunk core information.
 * @typedef {Object} ETagWithPartNumber
 * @property {string | null} ETag - a unique reference to this chunk associated to a pre-signed url.
 * @property {number} PartNumber - indicate where the chunk is positioned in order to reconhstruct the file with multiPartUpload/Download.
 */
export type ETagWithPartNumber = {
    ETag: string | undefined
    PartNumber: number
}

/**
 * Group the information when retrieving the validity of a contribution for a contributor.
 * @typedef {Object} ContributionValidity
 * @property {string} contributionId - the unique identifier of the contribution.
 * @property {string} circuitId - the unique identifier of the circuit for which the contribution was computed.
 * @property {boolean} valid - true if and only if the contribution is valid; otherwise false.
 */
export type ContributionValidity = {
    contributionId: string
    circuitId: string
    valid: boolean
}

/**
 * Necessary data to define a user database document.
 * @typedef {Object} UserDocument
 * @property {string} name - the name of the user.
 * @property {string | undefined} displayName - the public (visible) name of the user.
 * @property {number} creationTime - the timestamp when the document has been created.
 * @property {number} lastSignInTime - the timestamp when the user has been authenticated for the last time.
 * @property {number} lastUpdated - the timestamp where the last update of the Firestore document has happened.
 * @property {string} email - the email of the user.
 * @property {boolean} emailVerified - true when the email of the user has been verified; otherwise false.
 * @property {string | undefined} photoURL - the external url of the profile photo of the user.
 */
export type UserDocument = {
    name: string
    displayName: string | undefined
    creationTime: number
    lastSignInTime: number
    lastUpdated: number
    email: string
    emailVerified: boolean
    photoURL: string | undefined
}

/**
 * Groups all the information received as input from the coordinator when creating a ceremony.
 * @typedef {Object} CeremonyInputData
 * @property {string} title - the title/name of the ceremony.
 * @property {string} description - a brief description of the ceremony.
 * @property {number} startDate - the start (opening to contributions) date for the ceremony (in ms).
 * @property {number} endDate - the end (closing to contributions) date for the ceremony (in ms).
 * @property {CeremonyTimeoutType} timeoutMechanismType - the timeout mechanism type used for avoiding blocking contribution behaviours.
 * @property {number} penalty - the amount of time expressed in minutes that the blocking contributor has to wait before joining the waiting queue again.
 */
export type CeremonyInputData = {
    title: string
    description: string
    startDate: number
    endDate: number
    timeoutMechanismType: CeremonyTimeoutType
    penalty: number
}

/**
 * Group information about the version of the Circom compiler used for the ceremony circuits.
 * @typedef {Object} CircomCompilerData
 * @property {string} version - the version of the Circom compiler.
 * @property {string} commitHash - the commit hash of the version of the Circom compiler.
 */
export type CircomCompilerData = {
    version: string
    commitHash: string
}

/**
 * Group information about the Circom circuit template used for the ceremony circuits.
 * @dev we are assuming that the circuit template have been published to a public repository (as Github).
 * @typedef {Object} SourceTemplateData
 * @property {string} source - the external link where the circuit template has been published.
 * @property {string} commitHash - the commit hash of the version of the circuit template.
 * @property {Array<string>} paramsConfiguration - the list of parameter values used to configure the circuit template (if any).
 */
export type SourceTemplateData = {
    source: string
    commitHash: string
    paramsConfiguration: Array<string>
}

/**
 * The references about the artifacts produced during the compilation of the ceremony circuit.
 * @typedef {Object} CompilationArtifacts
 * @property {string} r1csFilename - the name of the R1CS file.
 * @property {string} wasmFilename - the name of the WASM file.
 */
export type CompilationArtifacts = {
    r1csFilename: string
    wasmFilename: string
}

/**
 * Group information about the VM configuration for circuit contribution verification.
 * @dev the coordinator could choose among CF and VM.
 * @notice the VM configurations could be retrieved at https://aws.amazon.com/ec2/instance-types/.
 * @typedef {Object} VMConfiguration
 * @property {string} [vmConfigurationType] - the VM configuration type.
 * @property {string} [vmDiskType] - the VM volume type (e.g., gp2)
 * @property {number} [vmDiskSize] - the VM disk size in GB.
 * @property {string} [vmInstanceId] - the VM instance identifier (after VM instantiation).
 */
export type VMConfiguration = {
    vmConfigurationType?: string
    vmDiskType?: DiskTypeForVM
    vmDiskSize?: number
    vmInstanceId?: string
}

/**
 * Group information about the circuit contribution verification mechanism.
 * @typedef {Object} CircuitContributionVerification
 * @property {CircuitContributionVerificationMechanism} cfOrVm - the mechanism chosen by the coordinator.
 * @property {VMConfiguration} [vm] - the VM configuration specs.
 */
export type CircuitContributionVerification = {
    cfOrVm: CircuitContributionVerificationMechanism
    vm?: VMConfiguration
}

/**
 * Group input data for defining a ceremony circuit.
 * @dev The data is both entered by the coordinator and derived.
 * @typedef {Object} CircuitInputData
 * @property {string} description - a short description for the circuit.
 * @property {CircomCompilerData} compiler - the info about the Circom compiler used to compile the circuit template.
 * @property {SourceTemplateData} template - the info about the circuit template.
 * @property {CircuitContributionVerification} verification - the info about the circuit contribution verification mechanism.
 * @property {CompilationArtifacts} compilationArtifacts - the references about the circuit compilation artifacts.
 * @property {CircuitMetadata} [metadata] - the info about the R1CS file.
 * @property {string} [name] - the name of the circuit.
 * @property {number} [dynamicThreshold] - the dynamic timeout threshold expressed in percentage.
 * @property {number} [fixedTimeWindow] - the amount of fixed max contribution time which can be spent while contributing before the timeout can be triggered.
 * @property {number} [sequencePosition] - the position which define the order of contributions in the ceremony.
 * @property {string} [prefix] - the prefix of the circuit derived from the name.
 * @property {number} [zKeySizeInBytes] - the size of the related zKey expressed in bytes.
 */
export type CircuitInputData = {
    description: string
    compiler: CircomCompilerData
    template: SourceTemplateData
    verification: CircuitContributionVerification
    compilationArtifacts?: CompilationArtifacts
    metadata?: CircuitMetadata
    name?: string
    dynamicThreshold?: number
    fixedTimeWindow?: number
    sequencePosition?: number
    prefix?: string
    zKeySizeInBytes?: number
}

/**
 * Necessary data to define a ceremony database document.
 * @dev The data is both entered by the coordinator and derived.
 * @typedef {Object} CeremonyDocument
 * @property {string} prefix - the prefix of the ceremony derived from the name.
 * @property {CeremonyState} state - the current state of the ceremony.
 * @property {CeremonyType} type - the type of the ceremony.
 * @property {string} coordinatorId - the unique identifier of the coordinator.
 * @property {number} lastUpdated - the timestamp where the last update of the Firestore document has happened.
 */
export type CeremonyDocument = CeremonyInputData & {
    prefix: string
    state: CeremonyState
    type: CeremonyType
    coordinatorId: string
    lastUpdated: number
}

/**
 * Data defining a contribution made by a participant.
 * @typedef {Object} Contribution
 * @property {string} doc - the unique identifier of the document related to the contribution.
 * @property {number} computationTime - the overall time spent while computing the contribution.
 * @property {string} hash - the contribution hash (generated as output from the snarkjs command).
 */
export type Contribution = {
    doc: string
    computationTime: number
    hash: string
}

/**
 * Auxiliary data needed for resumption in an intermediate step of contribution.
 * @dev The data is used when the current contributorinterrupts during the download, contribute, upload steps
 * to prevent it from having to start over but can pick up where it left off.
 * This restart operation does NOT interact with the timeout mechanism (which remains unchanged).
 * @typedef {Object} TemporaryParticipantContributionData
 * @property {number} contributionComputationTime - the time spent since the contribution start.
 * @property {string} uploadId - the unique identifier of the pre-signed url PUT request to upload the newest contribution.
 * @property {Array<ETagWithPartNumber>} chunks - the list of ETags and PartNumbers that make up the chunks.
 */
export type TemporaryParticipantContributionData = {
    contributionComputationTime: number
    uploadId: string
    chunks: Array<ETagWithPartNumber>
}

/**
 * Necessary data to define a participant database document.
 * @typedef {Object} ParticipantDocument
 * @property {string} userId - the unique identifier of the user associated with the participant.
 * @property {number} contributionProgress - indicates the number of the circuit for which the user has to wait in the queue.
 * @property {ParticipantStatus} status - the current status of the participant.
 * @property {Array<Contribution>} contributions - the list of references to the contributions computed by the participant.
 * @property {number} lastUpdated - the timestamp where the last update of the Firestore document has happened.
 * @property {number} [contributionStartedAt] - the timestamp of when the latest contribution has started.
 * @property {number} [verificationStartedAt] - the timestamp of when the latest verification process has started.
 * @property {TemporaryParticipantContributionData} [tempContributionData] - the auxiliary data needed for resumption in an intermediate step of contribution.
 */
export type ParticipantDocument = {
    userId: string
    contributionProgress: number
    status: ParticipantStatus
    contributions: Array<Contribution>
    lastUpdated: number
    contributionStartedAt: number
    contributionStep?: ParticipantContributionStep
    verificationStartedAt?: number
    tempContributionData?: TemporaryParticipantContributionData
}

/**
 * The metadata of a Groth16 circuit.
 * @dev The data is derived by reading the R1CS file.
 * @typedef {Object} CircuitMetadata
 * @property {string} curve - the curve used by the proving system for circuit construction.
 * @property {number} wires - the circuit amount of wires among field/gates.
 * @property {number} constraints - the amount of constraints (= the size of the circuit).
 * @property {number} privateInputs - the amount of private inputs (derived from constraints).
 * @property {number} publicInputs - the amount of public inputs (derived from constraints).
 * @property {number} labels - the amount of labels.
 * @property {number} outputs - the amount of outputs.
 * @property {number} pot - the smallest amount of powers needed to work with the circuit (Powers of Tau from Phase 1 setup).
 */
export type CircuitMetadata = {
    curve: string
    wires: number
    constraints: number
    privateInputs: number
    publicInputs: number
    labels: number
    outputs: number
    pot: number
}

/**
 * The references about the artifacts produced during the ceremony for a circuit.
 * @dev The references are related to the storage solution used where the files are stored (currently AWS S3).
 * @typedef {Object} CircuitArtifacts
 * @property {string} potFilename - the name of the Powers of Tau file.
 * @property {string} r1csFilename - the name of the R1CS file.
 * @property {string} wasmFilename - the name of the WASM file.
 * @property {string} initialZkeyFilename - the name of the initial (= genesis) zKey file.
 * @property {string} potStoragePath - the storage path of the Powers of Tau file.
 * @property {string} r1csStoragePath - the storage path of the R1CS file.
 * @property {string} wasmStoragePath - the storage path of the WASM file.
 * @property {string} initialZkeyStoragePath - the storage path of the initial (= genesis) zKey file.
 * @property {string} potBlake2bHash - the blake2b hash of the Powers of Tau file.
 * @property {string} r1csBlake2bHash - the blake2b hash of the R1CS file.
 * @property {string} wasmBlake2bHash - the blake2b hash of the WASM file.
 * @property {string} initialZkeyBlake2bHash - the blake2b hash of the initial (= genesis) zKey file.
 */
export type CircuitArtifacts = {
    potFilename: string
    r1csFilename: string
    wasmFilename: string
    initialZkeyFilename: string
    potStoragePath: string
    r1csStoragePath: string
    wasmStoragePath: string
    initialZkeyStoragePath: string
    potBlake2bHash: string
    r1csBlake2bHash: string
    wasmBlake2bHash: string
    initialZkeyBlake2bHash: string
}

/**
 * The references about the average time spent by contributors on the circuit.
 * @typedef {Object} CircuitTimings
 * @property {number} contributionComputation - the average amount of time spent for contribution computation only.
 * @property {number} fullContribution - the average amount of time spent for the whole contribution.
 * @property {number} verifyCloudFunction - the average amount of time spent for verification of contribution only.
 */
export type CircuitTimings = {
    contributionComputation: number
    fullContribution: number
    verifyCloudFunction: number
}

/**
 * The information to handle the queue for circuit contributions.
 * @typedef {Object} CircuitWaitingQueue
 * @property {number} completedContributions - the total amount of completed contributions.
 * @property {Array<string>} contributors - the list of unique identifiers of the participants waiting for contributing.
 * @property {string} currentContributor - the unique identifier of the participant who is currently contributing.
 * @property {number} failedContributions - the total amount of failed contributions.
 */
export type CircuitWaitingQueue = {
    completedContributions: number
    contributors: Array<string>
    currentContributor: string
    failedContributions: number
}

/**
 * Necessary data to define a circuit database document.
 * @typedef {Object} CircuitDocument
 * @property {CircuitMetadata} metadata - the info about the circuit metadata.
 * @property {CircuitArtifacts} [files] - the references about the circuit artifacts.
 * @property {CircuitTimings} [avgTimings] - the info about the average timings for the circuit.
 * @property {SourceTemplateData} [template] - the info about the circuit template.
 * @property {CircomCompilerData} [compiler] - the info about the circom compiler.
 * @property {CircuitWaitingQueue} [waitingQueue] - the info about the circuit waiting queue.
 * @property {number} [lastUpdated] - the timestamp where the last update of the Firestore document has happened.
 */
export type CircuitDocument = CircuitInputData & {
    metadata?: CircuitMetadata
    files?: CircuitArtifacts
    avgTimings?: CircuitTimings
    template?: SourceTemplateData
    compiler?: CircomCompilerData
    waitingQueue?: CircuitWaitingQueue
    lastUpdated?: number
}

/**
 * The references about the artifacts produced during the contribution (either final or not) to a ceremony circuit.
 * @dev The references are related to the storage solution used where the files are stored (currently AWS S3).
 * @typedef {Object} ContributionFiles
 * @property {string} transcriptFilename - the name of the transcript file.
 * @property {string} lastZkeyFilename - the name of the contribution (zKey) file.
 * @property {string} transcriptStoragePath - the storage path of the transcript file.
 * @property {string} lastZkeyStoragePath - the storage path of the contribution (zKey) file.
 * @property {string} transcriptBlake2bHash - the blake2b hash of the transcript file.
 * @property {string} lastZkeyBlake2bHash - the blake2b hash of the contribution (zKey) file.
 * @property {string} [verificationKeyBlake2bHash] - the blake2b hash of the verification key file (final contribution only).
 * @property {string} [verificationKeyFilename] - the name of the verification key file (final contribution only).
 * @property {string} [verificationKeyStoragePath] - the storage path of the verification key file (final contribution only).
 * @property {string} [verifierContractBlake2bHash] - the blake2b hash of the verifier smart contract file (final contribution only).
 * @property {string} [verifierContractFilename] - the name of the verifier smart contract file (final contribution only).
 * @property {string} [verifierContractStoragePath] - the storage path of the verifier smart contract file (final contribution only).
 */
export type ContributionFiles = {
    transcriptFilename: string
    lastZkeyFilename: string
    transcriptStoragePath: string
    lastZkeyStoragePath: string
    transcriptBlake2bHash: string
    lastZkeyBlake2bHash: string
    verificationKeyBlake2bHash?: string
    verificationKeyFilename?: string
    verificationKeyStoragePath?: string
    verifierContractBlake2bHash?: string
    verifierContractFilename?: string
    verifierContractStoragePath?: string
}

/**
 * Group information about the version of the verification software used for contribution verification.
 * @typedef {Object} ContributionVerificationSoftware
 * @property {string} name - the name of the verification software.
 * @property {string} version - the version of the verification software.
 * @property {string} commitHash - the commit hash of the version of the verification software.
 */
export type ContributionVerificationSoftware = {
    name: string
    version: string
    commitHash: string
}

/**
 * Group information about the value (beacon) used to compute the final contribution while finalizing the ceremony.
 * @typedef {Object} BeaconInfo
 * @property {string} value - the value of the beacon.
 * @property {string} hash - the SHA 256 hash of the beacon.
 */
export type BeaconInfo = {
    value: string
    hash: string
}

/**
 * Necessary data to define a contribution document.
 * @typedef {Object} ContributionDocument
 * @property {string} participantId - the unique identifier of the contributor.
 * @property {number} contributionComputationTime - the amount of time spent for the contribution (download, compute, upload).
 * @property {number} verificationComputationTime - the amount of time spent for the verification of the contribution.
 * @property {string} zkeyIndex - the index of the contribution.
 * @property {ContributionFiles} files - the references and hashes of the artifacts produced during the contribution (and verification).
 * @property {ContributionVerificationSoftware} verificationSoftware - the info about the verification software used to verify the contributions.
 * @property {boolean} valid - true if the contribution has been evaluated as valid; otherwise false.
 * @property {number} lastUpdated - the timestamp where the last update of the Firestore document has happened.
 * @property {BeaconInfo} beacon - the data about the value used to compute the final contribution while finalizing the ceremony (final contribution only).
 */
export type ContributionDocument = {
    participantId: string
    contributionComputationTime: number
    verificationComputationTime: number
    zkeyIndex: string
    files: ContributionFiles
    verificationSoftware: ContributionVerificationSoftware
    valid: boolean
    lastUpdated: number
    beacon?: BeaconInfo
}

/**
 * Define a circuit document reference and data.
 * @dev must be used for generating fake/mock documents when testing.
 * @typedef {Object} CircuitDocumentReferenceAndData
 * @property {string} uid - the unique identifier of the document.
 * @property {CircuitDocument} doc - the info about the circuit document.
 */
export type CircuitDocumentReferenceAndData = {
    uid: string
    data: CircuitDocument
}

/**
 * Define a user document reference and data.
 * @dev must be used for generating fake/mock documents when testing.
 * @typedef {Object} UserDocumentReferenceAndData
 * @property {string} uid - the unique identifier of the document.
 * @property {UserDocument} doc - the info about the user document.
 */
export type UserDocumentReferenceAndData = {
    uid: string
    data: UserDocument
}

/**
 * Define a ceremony document reference and data.
 * @dev must be used for generating fake/mock documents when testing.
 * @typedef {Object} CeremonyDocumentReferenceAndData
 * @property {string} uid - the unique identifier of the document.
 * @property {CeremonyDocument} doc - the info about the user document.
 */
export type CeremonyDocumentReferenceAndData = {
    uid: string
    data: CeremonyDocument
}

/**
 * Define a participant document reference and data.
 * @dev must be used for generating fake/mock documents when testing.
 * @typedef {Object} ParticipantDocumentReferenceAndData
 * @property {string} uid - the unique identifier of the document.
 * @property {ParticipantDocument} doc - the info about the user document.
 */
export type ParticipantDocumentReferenceAndData = {
    uid: string
    data: ParticipantDocument
}

/**
 * Define a ceremony artifacts with their local paths.
 * @typedef {Object} CeremonyArtifacts
 * @property {string} circuitPrefix - the prefix of the circuit.
 * @property {string} circuitId - the unique identifier of the circuit.
 * @property {string} directoryRoot - the root directory of the ceremony.
 * @property {string} potLocalFilePath - the local path of the pot file.
 * @property {string} r1csLocalFilePath - the local path of the r1cs file.
 * @property {string} finalZkeyLocalFilePath - the local path of the final zKey file.
 * @property {string} lastZkeyLocalFilePath - the local path of the last zKey file.
 * @property {string} verifierLocalFilePath - the local path of the verifier file.
 * @property {string} verificationKeyLocalFilePath - the local path of the verification key file.
 * @property {string} wasmLocalFilePath - the local path of the wasm file.
 * @dev must be used for generating fake/mock documents when testing.
 */
export type CeremonyArtifacts = {
    circuitPrefix: string
    circuitId: string
    directoryRoot: string
    potLocalFilePath: string
    r1csLocalFilePath: string
    finalZkeyLocalFilePath: string
    lastZkeyLocalFilePath: string
    verifierLocalFilePath: string
    verificationKeyLocalFilePath: string
    wasmLocalFilePath: string
}

/**
 * Define a contribution document reference and data.
 * @dev must be used for generating fake/mock documents when testing.
 * @typedef {Object} ContributionDocumentReferenceAndData
 * @property {string} uid - the unique identifier of the document.
 * @property {ContributionDocument} doc - the info about the contribution document.
 */
export type ContributionDocumentReferenceAndData = {
    uid: string
    data: ContributionDocument
}

/**
 * Group the details for a VM EC2 instance.
 * @typedef {Object} EC2Instance
 * @property {string} instanceId - the unique identifier of the VM.
 * @property {string} imageId - the unique identifier of the image.
 * @property {string} instanceType - the VM type.
 * @property {string} keyName - the name of the key.
 * @property {string} launchTime - the timestamp of the launch of the VM.
 */
export type EC2Instance = {
    instanceId: string
    imageId: string
    instanceType: string
    keyName: string
    launchTime: string
}

/**
 * Group the information of a Virtual Machine configuration type.
 * @typedef {Object} VMConfigurationType
 * @property {string} type - the name of the instance type (e.g., t3.small).
 * @property {string} ram - the amount of RAM.
 * @property {string} vcpu - the number of VCPUs.
 */
export type VMConfigurationType = {
    type: string
    ram: number
    vcpu: number
}

/**
 * Group the information required to setup a new ceremony
 * @typedef {Object} SetupCeremonyData
 * @property {CeremonyInputData} - the details of the ceremony
 * @property {string} - the ceremony prefix
 * @property {Array<CircuitDocument>} - the details of the circuits
 * @property {Array<CeremonyArtifacts>} - the details of the ceremony artifacts
 */
export type SetupCeremonyData = {
    ceremonyInputData: CeremonyInputData
    ceremonyPrefix: string
    circuits: Array<CircuitDocument>
    circuitArtifacts: Array<CeremonySetupTemplateCircuitArtifacts>
}

export type CeremonySetupTemplateCircuitArtifacts = {
    artifacts: {
        bucket: string
        region: string
        r1csStoragePath: string
        wasmStoragePath: string
    }
}

export type CeremonySetupTemplateCircuitTimeout = {
    dynamicThreshold: number
    fixedTimeWindow: number
}

export type CeremonySetupTemplateCircuitName = {
    name: string
}

export type CeremonySetupTemplate = {
    title: string
    description: string
    startDate: string
    endDate: string
    timeoutMechanismType: CeremonyTimeoutType
    penalty: number
    circuits: Array<
        CircuitDocument &
            CeremonySetupTemplateCircuitArtifacts &
            CeremonySetupTemplateCircuitTimeout &
            CeremonySetupTemplateCircuitName
    >
}

export type StringifiedBigInts =
    | StringifiedBigInts[]
    | string
    | string[]
    | string[][]
    | string[][][]
    | { [key: string]: StringifiedBigInts }
    | null

export type BigIntVariants =
    | BigIntVariants[]
    | StringifiedBigInts
    | bigint
    | bigint[]
    | bigint[][]
    | bigint[][][]
    | { [key: string]: BigIntVariants }
    | Uint8Array
    | null