@devtion/actions 0.0.0-7e983e3

package/src/helpers/vm.ts

@@ -0,0 +1,392 @@
+import {
+    DescribeInstanceStatusCommand,
+    RunInstancesCommand,
+    StartInstancesCommand,
+    StopInstancesCommand,
+    TerminateInstancesCommand,
+    EC2Client,
+    RunInstancesCommandInput
+} from "@aws-sdk/client-ec2"
+import {
+    GetCommandInvocationCommand,
+    SSMClient,
+    SendCommandCommand,
+    SendCommandCommandInput
+} from "@aws-sdk/client-ssm"
+import dotenv from "dotenv"
+import { DiskTypeForVM } from "src"
+import { EC2Instance } from "../types"
+import { convertBytesOrKbToGb } from "./utils"
+import { ec2InstanceTag, powersOfTauFiles, vmBootstrapScriptFilename } from "./constants"
+import { getAWSVariables } from "./services"
+
+dotenv.config()
+
+/**
+ * Create a new AWS EC2 client.
+ * @returns <Promise<EC2Client>> - the EC2 client instance.
+ */
+export const createEC2Client = async (): Promise<EC2Client> => {
+    // Get the AWS variables.
+    const { accessKeyId, secretAccessKey, region } = getAWSVariables()
+
+    // Instantiate the new client.
+    return new EC2Client({
+        credentials: {
+            accessKeyId,
+            secretAccessKey
+        },
+        region
+    })
+}
+
+/**
+ * Create a new AWS SSM client.
+ * @returns <Promise<SSMClient>> - the SSM client instance.
+ */
+export const createSSMClient = async (): Promise<SSMClient> => {
+    // Get the AWS variables.
+    const { accessKeyId, secretAccessKey, region } = getAWSVariables()
+
+    // Instantiate the new client.
+    return new SSMClient({
+        credentials: {
+            accessKeyId,
+            secretAccessKey
+        },
+        region
+    })
+}
+
+/**
+ * Return the list of bootstrap commands to be executed.
+ * @dev the startup commands must be suitable for a shell script.
+ * @param bucketName <string> - the name of the AWS S3 bucket.
+ * @returns <Array<string>> - the list of startup commands to be executed.
+ */
+export const vmBootstrapCommand = (bucketName: string): Array<string> => [
+    "#!/bin/bash", // shabang.
+    `aws s3 cp s3://${bucketName}/${vmBootstrapScriptFilename} ${vmBootstrapScriptFilename}`, // copy file from S3 bucket to VM.
+    `chmod +x ${vmBootstrapScriptFilename} && bash ${vmBootstrapScriptFilename}` // grant permission and execute.
+]
+
+/**
+ * Return the list of Node environment (and packages) installation plus artifact caching for contribution verification.
+ * @param zKeyPath <string> - the path to zKey artifact inside AWS S3 bucket.
+ * @param potPath <string> - the path to ptau artifact inside AWS S3 bucket.
+ * @param snsTopic <string> - the SNS topic ARN.
+ * @param region <string> - the AWS region.
+ * @returns <Array<string>> - the array of commands to be run by the EC2 instance.
+ */
+export const vmDependenciesAndCacheArtifactsCommand = (
+    zKeyPath: string,
+    potPath: string,
+    snsTopic: string,
+    region: string 
+): Array<string> => [
+    "#!/bin/bash",
+    'MARKER_FILE="/var/run/my_script_ran"',
+    // eslint-disable-next-line no-template-curly-in-string
+    "if [ -e ${MARKER_FILE} ]; then",
+    "exit 0",
+    "else",
+    // eslint-disable-next-line no-template-curly-in-string
+    "touch ${MARKER_FILE}",
+    "sudo yum update -y",
+    "curl -sL https://rpm.nodesource.com/setup_16.x | sudo bash - ",
+    "sudo yum install -y nodejs",
+    "npm install -g snarkjs",
+    `aws s3 cp s3://${zKeyPath} /var/tmp/genesisZkey.zkey`,
+    `aws s3 cp s3://${potPath} /var/tmp/pot.ptau`,
+    "wget https://github.com/BLAKE3-team/BLAKE3/releases/download/1.4.0/b3sum_linux_x64_bin -O /var/tmp/blake3.bin",
+    "chmod +x /var/tmp/blake3.bin",
+    "INSTANCE_ID=$(ec2-metadata -i | awk '{print $2}')",
+    `aws sns publish --topic-arn ${snsTopic} --message "$INSTANCE_ID" --region ${region}`,
+    "fi"
+]
+
+/**
+ * Return the list of commands for contribution verification.
+ * @dev this method generates the verification transcript as well.
+ * @param bucketName <string> - the name of the AWS S3 bucket.
+ * @param lastZkeyStoragePath <string> - the last zKey storage path.
+ * @param verificationTranscriptStoragePathAndFilename <string> - the verification transcript storage path.
+ * @returns Array<string> - the list of commands for contribution verification.
+ */
+export const vmContributionVerificationCommand = (
+    bucketName: string,
+    lastZkeyStoragePath: string,
+    verificationTranscriptStoragePathAndFilename: string
+): Array<string> => [
+    `aws s3 cp s3://${bucketName}/${lastZkeyStoragePath} /var/tmp/lastZKey.zkey > /var/tmp/log.txt`,
+    `snarkjs zkvi /var/tmp/genesisZkey.zkey /var/tmp/pot.ptau /var/tmp/lastZKey.zkey > /var/tmp/verification_transcript.log`,
+    `aws s3 cp /var/tmp/verification_transcript.log s3://${bucketName}/${verificationTranscriptStoragePathAndFilename} &>/dev/null`,
+    `/var/tmp/blake3.bin /var/tmp/verification_transcript.log | awk '{print $1}'`,
+    `rm /var/tmp/lastZKey.zkey /var/tmp/verification_transcript.log /var/tmp/log.txt &>/dev/null`
+]
+
+/**
+ * Compute the VM disk size.
+ * @dev the disk size is computed using the zKey size in bytes taking into consideration
+ * the verification task (2 * zKeySize) + ptauSize + OS/VM (~8GB).
+ * @param zKeySizeInBytes <number> the size of the zKey in bytes.
+ * @param pot <number> the amount of powers needed for the circuit (index of the PPoT file).
+ * @return <number> the configuration of the VM disk size in GB.
+ */
+export const computeDiskSizeForVM = (zKeySizeInBytes: number, pot: number): number =>
+    Math.ceil(2 * convertBytesOrKbToGb(zKeySizeInBytes, true) + powersOfTauFiles[pot - 1].size) + 8
+
+/**
+ * Creates a new EC2 instance
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param commands <Array<string>> - the list of commands to be run on the EC2 instance.
+ * @param instanceType <string> - the type of the EC2 VM instance.
+ * @param diskSize <number> - the size of the disk (volume) of the VM.
+ * @param diskType <DiskTypeForVM> - the type of the disk (volume) of the VM.
+ * @returns <Promise<P0tionEC2Instance>> the instance that was created
+ */
+export const createEC2Instance = async (
+    ec2: EC2Client,
+    commands: string[],
+    instanceType: string,
+    volumeSize: number,
+    diskType: DiskTypeForVM
+): Promise<EC2Instance> => {
+    // Get the AWS variables.
+    const { amiId, roleArn } = getAWSVariables()
+
+    // Parametrize the VM EC2 instance.
+    const params: RunInstancesCommandInput = {
+        ImageId: amiId,
+        InstanceType: instanceType,
+        MaxCount: 1,
+        MinCount: 1,
+        // nb. to find this: iam -> roles -> role_name.
+        IamInstanceProfile: {
+            Arn: roleArn
+        },
+        // nb. for running commands at the startup.
+        UserData: Buffer.from(commands.join("\n")).toString("base64"),
+        BlockDeviceMappings: [
+            {
+                DeviceName: "/dev/xvda",
+                Ebs: {
+                    DeleteOnTermination: true,
+                    VolumeSize: volumeSize, // disk size in GB.
+                    VolumeType: diskType
+                }
+            }
+        ],
+        // tag the resource
+        TagSpecifications: [
+            {
+                ResourceType: "instance",
+                Tags: [
+                    {
+                        Key: "Name",
+                        Value: ec2InstanceTag
+                    },
+                    {
+                        Key: "Initialized",
+                        Value: "false"
+                    }
+                ]
+            }
+        ]
+    }
+
+    try {
+        // Create a new command instance.
+        const command = new RunInstancesCommand(params)
+        // Send the command for execution.
+        const response = await ec2.send(command)
+
+        if (response.$metadata.httpStatusCode !== 200)
+            throw new Error(`Something went wrong when creating the EC2 instance. More details ${response}`)
+
+        // Create a new EC2 VM instance.
+        return {
+            instanceId: response.Instances![0].InstanceId!,
+            imageId: response.Instances![0].ImageId!,
+            instanceType: response.Instances![0].InstanceType!,
+            keyName: response.Instances![0].KeyName!,
+            launchTime: response.Instances![0].LaunchTime!.toISOString()
+        }
+    } catch (error: any) {
+        throw new Error(`Something went wrong when creating the EC2 instance. More details ${error}`)
+    }
+}
+
+/**
+ * Check if the current VM EC2 instance is running by querying the status.
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ * @returns <Promise<boolean>> - true if the current status of the EC2 VM instance is 'running'; otherwise false.
+ */
+export const checkIfRunning = async (ec2Client: EC2Client, instanceId: string): Promise<boolean> => {
+    // Generate a new describe status command.
+    const command = new DescribeInstanceStatusCommand({
+        InstanceIds: [instanceId]
+    })
+
+    // Run the command.
+    const response = await ec2Client.send(command)
+
+    if (response.$metadata.httpStatusCode !== 200)
+        throw new Error(
+            `Something went wrong when retrieving the EC2 instance (${instanceId}) status. More details ${response}`
+        )
+
+    return response.InstanceStatuses![0].InstanceState!.Name === "running"
+}
+
+/**
+ * Start an EC2 VM instance.
+ * @dev the instance must have been created previously.
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ */
+export const startEC2Instance = async (ec2: EC2Client, instanceId: string) => {
+    // Generate a new start instance command.
+    const command = new StartInstancesCommand({
+        InstanceIds: [instanceId],
+        DryRun: false
+    })
+
+    // Run the command.
+    const response = await ec2.send(command)
+
+    if (response.$metadata.httpStatusCode !== 200)
+        throw new Error(`Something went wrong when starting the EC2 instance (${instanceId}). More details ${response}`)
+}
+
+/**
+ * Stop an EC2 VM instance.
+ * @dev the instance must have been in a running status.
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ */
+export const stopEC2Instance = async (ec2: EC2Client, instanceId: string) => {
+    // Generate a new stop instance command.
+    const command = new StopInstancesCommand({
+        InstanceIds: [instanceId],
+        DryRun: false
+    })
+
+    // Run the command.
+    const response = await ec2.send(command)
+
+    if (response.$metadata.httpStatusCode !== 200)
+        throw new Error(`Something went wrong when stopping the EC2 instance (${instanceId}). More details ${response}`)
+}
+
+/**
+ * Terminate an EC2 VM instance.
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ */
+export const terminateEC2Instance = async (ec2: EC2Client, instanceId: string) => {
+    // Generate a new terminate instance command.
+    const command = new TerminateInstancesCommand({
+        InstanceIds: [instanceId],
+        DryRun: false
+    })
+
+    // Run the command.
+    const response = await ec2.send(command)
+
+    if (response.$metadata.httpStatusCode !== 200)
+        throw new Error(
+            `Something went wrong when terminating the EC2 instance (${instanceId}). More details ${response}`
+        )
+}
+
+/**
+ * Run a command on an EC2 VM instance by using SSM.
+ * @dev this method returns the command identifier for checking the status and retrieve
+ * the output of the command execution later on.
+ * @param ssm <SSMClient> - the instance of the sSM client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ * @param commands <Array<string>> - the list of commands.
+ * @return <Promise<string>> - the unique identifier of the command.
+ */
+export const runCommandUsingSSM = async (
+    ssm: SSMClient,
+    instanceId: string,
+    commands: Array<string>
+): Promise<string> => {
+    // Generate a new send command input command.
+    const params: SendCommandCommandInput = {
+        DocumentName: "AWS-RunShellScript",
+        InstanceIds: [instanceId],
+        Parameters: {
+            commands
+        },
+        TimeoutSeconds: 1200
+    }
+
+    try {
+        // Run the command.
+        const response = await ssm.send(new SendCommandCommand(params))
+
+        // if (response.$metadata.httpStatusCode !== 200)
+        //     throw new Error(
+        //         `Something went wrong when trying to run a command on the EC2 instance (${instanceId}). More details ${response}`
+        //     )
+
+        return response.Command!.CommandId!
+    } catch (error: any) {
+        throw new Error(`Something went wrong when trying to run a command on the EC2 instance. More details ${error}`)
+    }
+}
+
+/**
+ * Get the output of an SSM command executed on an EC2 VM instance.
+ * @param ssm <SSMClient> - the instance of the sSM client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ * @param commandId <string> - the unique identifier of the command.
+ * @return <Promise<string>> - the command output.
+ */
+export const retrieveCommandOutput = async (ssm: SSMClient, instanceId: string, commandId: string): Promise<string> => {
+    // Generate a new get command invocation command.
+    const command = new GetCommandInvocationCommand({
+        CommandId: commandId,
+        InstanceId: instanceId
+    })
+
+    try {
+        // Run the command.
+        const response = await ssm.send(command)
+
+        return response.StandardOutputContent!
+    } catch (error: any) {
+        throw new Error(
+            `Something went wrong when trying to retrieve the command ${commandId} output on the EC2 instance (${instanceId}). More details ${error}`
+        )
+    }
+}
+
+/**
+ * Get the status of an SSM command executed on an EC2 VM instance.
+ * @param ssm <SSMClient> - the instance of the sSM client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ * @param commandId <string> - the unique identifier of the command.
+ * @return <Promise<string>> - the command status.
+ */
+export const retrieveCommandStatus = async (ssm: SSMClient, instanceId: string, commandId: string): Promise<string> => {
+    // Generate a new get command invocation command.
+    const command = new GetCommandInvocationCommand({
+        CommandId: commandId,
+        InstanceId: instanceId
+    })
+
+    try {
+        // Run the command.
+        const response = await ssm.send(command)
+        return response.Status!
+    } catch (error: any) {
+        throw new Error(
+            `Something went wrong when trying to retrieve the command ${commandId} status on the EC2 instance (${instanceId}). More details ${error}`
+        )
+    }
+}

package/src/index.ts

@@ -0,0 +1,162 @@
+export {
+    downloadCeremonyArtifact,
+    getBucketName,
+    multiPartUpload,
+    getR1csStorageFilePath,
+    getPotStorageFilePath,
+    getZkeyStorageFilePath,
+    getVerificationKeyStorageFilePath,
+    getVerifierContractStorageFilePath,
+    getTranscriptStorageFilePath,
+    getWasmStorageFilePath
+} from "./helpers/storage"
+export {
+    queryCollection,
+    fromQueryToFirebaseDocumentInfo,
+    getAllCollectionDocs,
+    getCircuitContributionsFromContributor,
+    getDocumentById,
+    getCurrentActiveParticipantTimeout,
+    getClosedCeremonies,
+    getParticipantsCollectionPath,
+    getCircuitsCollectionPath,
+    getContributionsCollectionPath,
+    getTimeoutsCollectionPath,
+    getOpenedCeremonies,
+    getCeremonyCircuits
+} from "./helpers/database"
+export {
+    compareCeremonyArtifacts,
+    downloadAllCeremonyArtifacts,
+    exportVerifierAndVKey,
+    exportVerifierContract,
+    exportVkey,
+    generateGROTH16Proof,
+    generateZkeyFromScratch,
+    verifyGROTH16Proof,
+    verifyZKey
+} from "./helpers/verification"
+export { initializeFirebaseCoreServices } from "./helpers/services"
+export { signInToFirebaseWithCredentials, getCurrentFirebaseAuthUser, isCoordinator } from "./helpers/authentication"
+export {
+    commonTerms,
+    potFileDownloadMainUrl,
+    potFilenameTemplate,
+    genesisZkeyIndex,
+    numExpIterations,
+    solidityVersion,
+    finalContributionIndex,
+    verificationKeyAcronym,
+    verifierSmartContractAcronym,
+    ec2InstanceTag,
+    vmConfigurationTypes,
+    vmBootstrapScriptFilename,
+    powersOfTauFiles
+} from "./helpers/constants"
+export {
+    extractPrefix,
+    extractPoTFromFilename,
+    extractR1CSInfoValueForGivenKey,
+    formatZkeyIndex,
+    autoGenerateEntropy,
+    getCircuitBySequencePosition,
+    convertBytesOrKbToGb,
+    getPublicAttestationPreambleForContributor,
+    getContributionsValidityForContributor,
+    generateValidContributionsAttestation,
+    createCustomLoggerForFile,
+    getR1CSInfo,
+    computeSmallestPowersOfTauForCircuit,
+    convertToDoubleDigits,
+    parseCeremonyFile
+} from "./helpers/utils"
+export {
+    setupCeremony,
+    checkParticipantForCeremony,
+    progressToNextCircuitForContribution,
+    resumeContributionAfterTimeoutExpiration,
+    createS3Bucket,
+    generateGetObjectPreSignedUrl,
+    progressToNextContributionStep,
+    permanentlyStoreCurrentContributionTimeAndHash,
+    temporaryStoreCurrentContributionMultiPartUploadId,
+    temporaryStoreCurrentContributionUploadedChunkData,
+    generatePreSignedUrlsParts,
+    completeMultiPartUpload,
+    checkIfObjectExist,
+    verifyContribution,
+    checkAndPrepareCoordinatorForFinalization,
+    finalizeCircuit,
+    finalizeCeremony    
+} from "./helpers/functions"
+export { toHex, blake512FromPath, computeSHA256ToHex, compareHashes } from "./helpers/crypto"
+export {
+    compileContract,
+    verifyCeremony,
+    p256,
+    verifyGROTH16ProofOnChain,
+    formatSolidityCalldata
+} from "./helpers/contracts"
+export { githubReputation } from "./helpers/security"
+export {
+    CeremonyState,
+    CeremonyType,
+    CeremonyTimeoutType,
+    ParticipantStatus,
+    ParticipantContributionStep,
+    TimeoutType,
+    RequestType,
+    TestingEnvironment,
+    CircuitContributionVerificationMechanism,
+    DiskTypeForVM
+} from "./types/enums"
+export {
+    FirebaseDocumentInfo,
+    ChunkWithUrl,
+    ETagWithPartNumber,
+    ContributionValidity,
+    UserDocument,
+    CeremonyInputData,
+    CircomCompilerData,
+    SourceTemplateData,
+    CompilationArtifacts,
+    CircuitInputData,
+    CeremonyDocument,
+    Contribution,
+    TemporaryParticipantContributionData,
+    ParticipantDocument,
+    CircuitMetadata,
+    CircuitArtifacts,
+    CircuitTimings,
+    CircuitWaitingQueue,
+    CircuitDocument,
+    ContributionFiles,
+    ContributionVerificationSoftware,
+    BeaconInfo,
+    ContributionDocument,
+    CircuitDocumentReferenceAndData,
+    UserDocumentReferenceAndData,
+    CeremonyDocumentReferenceAndData,
+    ParticipantDocumentReferenceAndData,
+    CeremonyArtifacts,
+    ContributionDocumentReferenceAndData,
+    FirebaseServices,
+    VMConfigurationType,
+    AWSVariables
+} from "./types/index"
+export {
+    createEC2Instance,
+    terminateEC2Instance,
+    stopEC2Instance,
+    startEC2Instance,
+    checkIfRunning,
+    vmBootstrapCommand,
+    vmDependenciesAndCacheArtifactsCommand,
+    retrieveCommandOutput,
+    computeDiskSizeForVM,
+    createSSMClient,
+    runCommandUsingSSM,
+    createEC2Client,
+    vmContributionVerificationCommand,
+    retrieveCommandStatus
+} from "./helpers/vm"

package/src/types/enums.ts

@@ -0,0 +1,141 @@
+/**
+ * Define different states of a ceremony.
+ * @enum {string}
+ * - SCHEDULED: when the ceremony setup has been properly completed but the contribution period has not yet started.
+ * - OPENED: when the contribution period has started.
+ * - PAUSED: When the coordinator has manually paused the ceremony (NB. currently not possible because the relevant functionality has not yet been implemented).
+ * - CLOSED: when the contribution period has finished.
+ * - FINALIZED: when the ceremony finalization has been properly completed.
+ */
+export const enum CeremonyState {
+    SCHEDULED = "SCHEDULED",
+    OPENED = "OPENED",
+    PAUSED = "PAUSED",
+    CLOSED = "CLOSED",
+    FINALIZED = "FINALIZED"
+}
+
+/**
+ * Define the type of Trusted Setup ceremony (Phase 1 or Phase 2).
+ * @enum {string}
+ * - PHASE1: when the ceremony is a Phase 1 Trusted Setup ceremony.
+ * - PHASE2: when the ceremony is a Phase 2 Trusted Setup ceremony.
+ */
+export const enum CeremonyType {
+    PHASE1 = "PHASE1",
+    PHASE2 = "PHASE2"
+}
+
+/**
+ * Define different status of a participant.
+ * @enum {string}
+ * - CREATED: when the participant document has been created in the database.
+ * - WAITING: when the participant is waiting for a contribution (i.e., is currently queued or is waiting for its status to be checked after a timeout expiration).
+ * - READY: when the participant is ready for a contribution.
+ * - CONTRIBUTING: when the participant is currently contributing (i.e., not queued anymore, but the current contributor at this time).
+ * - CONTRIBUTED: when the participant has completed successfully the contribution for all circuits in a ceremony. The participant may need to wait for the latest contribution verification while having this status.
+ * - DONE: when the participant has completed contributions and verifications from coordinator.
+ * - FINALIZING: when the coordinator is currently finalizing the ceremony.
+ * - FINALIZED: when the coordinator has successfully finalized the ceremony.
+ * - TIMEDOUT: when the participant has been timedout while contributing. This may happen due to network or memory issues, un/intentional crash, or contributions lasting for too long.
+ * - EXHUMED: when the participant is ready to resume the contribution after a timeout expiration.
+ */
+export const enum ParticipantStatus {
+    CREATED = "CREATED",
+    WAITING = "WAITING",
+    READY = "READY",
+    CONTRIBUTING = "CONTRIBUTING",
+    CONTRIBUTED = "CONTRIBUTED",
+    DONE = "DONE",
+    FINALIZING = "FINALIZING",
+    FINALIZED = "FINALIZED",
+    TIMEDOUT = "TIMEDOUT",
+    EXHUMED = "EXHUMED"
+}
+
+/**
+ * Define different steps during which the participant may be during the contribution.
+ * @enum {string}
+ * - DOWNLOADING: when the participant is doing the download of the last contribution (from previous participant).
+ * - COMPUTING: when the participant is actively computing the contribution.
+ * - UPLOADING: when the participant is uploading the computed contribution.
+ * - VERIFYING: when the participant is waiting from verification results from the coordinator.
+ * - COMPLETED: when the participant has received the verification results from the coordinator and completed the contribution steps.
+ */
+export const enum ParticipantContributionStep {
+    DOWNLOADING = "DOWNLOADING",
+    COMPUTING = "COMPUTING",
+    UPLOADING = "UPLOADING",
+    VERIFYING = "VERIFYING",
+    COMPLETED = "COMPLETED"
+}
+
+/**
+ * Define what type of timeout was performed.
+ * @enum {string}
+ * - BLOCKING_CONTRIBUTION: when the current contributor was blocking the waiting queue.
+ * - BLOCKING_CLOUD_FUNCTION: when the contribution verification has gone beyond the time limit.
+ */
+export const enum TimeoutType {
+    BLOCKING_CONTRIBUTION = "BLOCKING_CONTRIBUTION",
+    BLOCKING_CLOUD_FUNCTION = "BLOCKING_CLOUD_FUNCTION"
+}
+
+/**
+ * Define what type of timeout mechanism is currently adopted for a ceremony.
+ * @enum {string}
+ * - DYNAMIC: self-update approach based on latest contribution time.
+ * - FIXED: approach based on a fixed amount of time.
+ */
+export const enum CeremonyTimeoutType {
+    DYNAMIC = "DYNAMIC",
+    FIXED = "FIXED"
+}
+
+/**
+ * Define request type for pre-signed urls.
+ */
+export const enum RequestType {
+    PUT = "PUT",
+    GET = "GET"
+}
+
+/**
+ * Define the environment in use when testing.
+ * @enum {string}
+ * - DEVELOPMENT: tests are performed on the local Firebase emulator instance.
+ * - PRODUCTION: tests are performed on the remote (deployed) Firebase application.
+ */
+export const enum TestingEnvironment {
+    DEVELOPMENT = "DEVELOPMENT",
+    PRODUCTION = "PRODUCTION"
+}
+
+/**
+ * Define what type of contribution verification mechanism is currently adopted for a circuit.
+ * @enum {string}
+ * - CF: Cloud Functions.
+ * - VM: Virtual Machine.
+ */
+export const enum CircuitContributionVerificationMechanism {
+    CF = "CF",
+    VM = "VM"
+}
+
+/**
+ * Define the supported VM volume types.
+ * @dev the VM volume types can be retrieved at https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html
+ * @enum {string}
+ * - GP2: General Purpose SSD version 2.
+ * - GP3: General Purpose SSD version 3.
+ * - IO1: Provisioned IOPS SSD volumes version 1.
+ * - ST1: Throughput Optimized HDD volumes.
+ * - SC1: Cold HDD volumes.
+ */
+export const enum DiskTypeForVM {
+    GP2 = "gp2",
+    GP3 = "gp3",
+    IO1 = "io1",
+    ST1 = "st1",
+    SC1 = "sc1"
+}