@devtion/backend 0.0.0-7e983e3

package/dist/types/functions/ceremony.d.ts

@@ -0,0 +1,33 @@
+import * as functions from "firebase-functions";
+/**
+ * Make a scheduled ceremony open.
+ * @dev this function automatically runs every 30 minutes.
+ * @todo this methodology for transitioning a ceremony from `scheduled` to `opened` state will be replaced with one
+ * that resolves the issues presented in the issue #192 (https://github.com/quadratic-funding/mpc-phase2-suite/issues/192).
+ */
+export declare const startCeremony: functions.CloudFunction<unknown>;
+/**
+ * Make a scheduled ceremony close.
+ * @dev this function automatically runs every 30 minutes.
+ * @todo this methodology for transitioning a ceremony from `opened` to `closed` state will be replaced with one
+ * that resolves the issues presented in the issue #192 (https://github.com/quadratic-funding/mpc-phase2-suite/issues/192).
+ */
+export declare const stopCeremony: functions.CloudFunction<unknown>;
+/**
+ * Register all ceremony setup-related documents on the Firestore database.
+ * @dev this function will create a new document in the `ceremonies` collection and as needed `circuit`
+ * documents in the sub-collection.
+ */
+export declare const setupCeremony: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Prepare all the necessary information needed for initializing the waiting queue of a circuit.
+ * @dev this function will add a new field `waitingQueue` in the newly created circuit document.
+ */
+export declare const initEmptyWaitingQueueForCircuit: functions.CloudFunction<functions.firestore.QueryDocumentSnapshot>;
+/**
+ * Conclude the finalization of the ceremony.
+ * @dev checks that the ceremony is closed (= CLOSED), the coordinator is finalizing and has already
+ * provided the final contribution for each ceremony circuit.
+ */
+export declare const finalizeCeremony: functions.HttpsFunction & functions.Runnable<any>;
+//# sourceMappingURL=ceremony.d.ts.map

package/dist/types/functions/ceremony.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceremony.d.ts","sourceRoot":"","sources":["../../../src/functions/ceremony.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAuC/C;;;;;GAKG;AACH,eAAO,MAAM,aAAa,kCAiBpB,CAAA;AAEN;;;;;GAKG;AACH,eAAO,MAAM,YAAY,kCAkBnB,CAAA;AAEN;;;;GAIG;AACH,eAAO,MAAM,aAAa,mDAyHpB,CAAA;AAEN;;;GAGG;AACH,eAAO,MAAM,+BAA+B,oEAsCtC,CAAA;AAEN;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,mDAiEvB,CAAA"}

package/dist/types/functions/circuit.d.ts

@@ -0,0 +1,63 @@
+import * as functionsV1 from "firebase-functions/v1";
+import * as functionsV2 from "firebase-functions/v2";
+import { VerifyContributionData } from "../types/index";
+/**
+ * This method is used to coordinate the waiting queues of ceremony circuits.
+ * @dev this cloud function is triggered whenever an update of a document related to a participant of a ceremony occurs.
+ * The function verifies that such update is preparatory towards a waiting queue update for one or more circuits in the ceremony.
+ * If that's the case, this cloud functions proceeds with the "coordination" of the waiting queues, leading to three different scenarios:
+ * A) The participant becomes the current contributor of circuit X (single participant).
+ * B) The participant is placed in the contribution waiting queue because someone else is currently contributing to circuit X (single participant)
+ * C) The participant is removed as current contributor from Circuit X and gets coordinated for Circuit X + 1 (multi-participant).
+ *    C.1) The first participant in the waiting queue for Circuit X (if any), becomes the new contributor for circuit X.
+ * Before triggering the above scenarios, the cloud functions verifies that suitable pre-conditions are met.
+ * @notice The cloud function performs the subsequent steps:
+ * 0) Prepares the participant's previous and current data (after/before document change).
+ * 1) Retrieve the ceremony from the participant's document path.
+ * 2) Verifies that the participant has changed to a state for which it is ready for contribution.
+ * 2.A) If ready, verifies whether the participant is ready to:
+ * - Contribute for the first time or for the next circuit (other than the first) or contribute after a timeout has expired. If yes, coordinate (single participant scenario).
+ * 2.B) Otherwise, check whether the participant has:
+ * - Just completed a contribution or all contributions for each circuit. If yes, coordinate (multi-participant scenario).
+ */
+export declare const coordinateCeremonyParticipant: functionsV1.CloudFunction<functionsV1.Change<functionsV1.firestore.QueryDocumentSnapshot>>;
+/**
+ * Verify the contribution of a participant computed while contributing to a specific circuit of a ceremony.
+ * @dev a huge amount of resources (memory, CPU, and execution time) is required for the contribution verification task.
+ * For this reason, we are using a V2 Cloud Function (more memory, more CPU, and longer timeout).
+ * Through the current configuration (16GiB memory and 4 vCPUs) we are able to support verification of contributions for 3.8M constraints circuit size.
+  @notice The cloud function performs the subsequent steps:
+ * 0) Prepare documents and extract necessary data.
+ * 1) Check if the participant is the current contributor to the circuit or is the ceremony coordinator
+ * 1.A) If either condition is true:
+ *   1.A.1) Prepare verification transcript logger, storage, and temporary paths.
+ *   1.A.2) Download necessary AWS S3 ceremony bucket artifacts.
+ *   1.A.3) Execute contribution verification.
+ *     1.A.3.0) Check if is using VM or CF approach for verification.
+ *     1.A.3.1) Start the instance and wait until the instance is up.
+ *     1.A.3.2) Prepare and run contribution verification command.
+ *     1.A.3.3) Wait until command complete.
+ *   1.A.4) Check contribution validity:
+ *   1.A.4.A) If valid:
+ *     1.A.4.A.1) Upload verification transcript to AWS S3 storage.
+ *     1.A.4.A.2) Creates a new valid contribution document on Firestore.
+ *   1.A.4.B) If not valid:
+ *     1.A.4.B.1) Creates a new invalid contribution document on Firestore.
+ *   1.A.4.C) Check if not finalizing:
+ *       1.A.4.C.1) If true, update circuit waiting for queue and average timings accordingly to contribution verification results;
+ * 2) Send all updates atomically to the Firestore database.
+ */
+export declare const verifycontribution: functionsV2.https.CallableFunction<VerifyContributionData, Promise<any>>;
+/**
+ * Update the related participant's document after verification of its last contribution.
+ * @dev this cloud functions is responsible for preparing the participant for the contribution toward the next circuit.
+ * this does not happen if the participant is actually the coordinator who is finalizing the ceremony.
+ */
+export declare const refreshParticipantAfterContributionVerification: functionsV1.CloudFunction<functionsV1.firestore.QueryDocumentSnapshot>;
+/**
+ * Finalize the ceremony circuit.
+ * @dev this cloud function stores the hashes and storage references of the Verifier smart contract
+ * and verification key extracted from the circuit final contribution (as part of the ceremony finalization process).
+ */
+export declare const finalizeCircuit: functionsV1.HttpsFunction & functionsV1.Runnable<any>;
+//# sourceMappingURL=circuit.d.ts.map

package/dist/types/functions/circuit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit.d.ts","sourceRoot":"","sources":["../../../src/functions/circuit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,uBAAuB,CAAA;AACpD,OAAO,KAAK,WAAW,MAAM,uBAAuB,CAAA;AAyCpD,OAAO,EAAuB,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAyR5E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,6BAA6B,4FAoGpC,CAAA;AA8BN;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,kBAAkB,0EAya9B,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,+CAA+C,wEA4EtD,CAAA;AAEN;;;;GAIG;AACH,eAAO,MAAM,eAAe,uDA8EtB,CAAA"}

package/dist/types/functions/index.d.ts

@@ -0,0 +1,7 @@
+export { registerAuthUser, processSignUpWithCustomClaims } from "./user";
+export { startCeremony, stopCeremony, setupCeremony, initEmptyWaitingQueueForCircuit, finalizeCeremony } from "./ceremony";
+export { checkParticipantForCeremony, progressToNextContributionStep, permanentlyStoreCurrentContributionTimeAndHash, temporaryStoreCurrentContributionMultiPartUploadId, temporaryStoreCurrentContributionUploadedChunkData, progressToNextCircuitForContribution, checkAndPrepareCoordinatorForFinalization } from "./participant";
+export { coordinateCeremonyParticipant, verifycontribution, refreshParticipantAfterContributionVerification, finalizeCircuit } from "./circuit";
+export { createBucket, checkIfObjectExist, generateGetObjectPreSignedUrl, startMultiPartUpload, generatePreSignedUrlsParts, completeMultiPartUpload } from "./storage";
+export { checkAndRemoveBlockingContributor, resumeContributionAfterTimeoutExpiration } from "./timeout";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/functions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/functions/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,MAAM,QAAQ,CAAA;AACxE,OAAO,EACH,aAAa,EACb,YAAY,EACZ,aAAa,EACb,+BAA+B,EAC/B,gBAAgB,EACnB,MAAM,YAAY,CAAA;AACnB,OAAO,EACH,2BAA2B,EAC3B,8BAA8B,EAC9B,8CAA8C,EAC9C,kDAAkD,EAClD,kDAAkD,EAClD,oCAAoC,EACpC,yCAAyC,EAC5C,MAAM,eAAe,CAAA;AACtB,OAAO,EACH,6BAA6B,EAC7B,kBAAkB,EAClB,+CAA+C,EAC/C,eAAe,EAClB,MAAM,WAAW,CAAA;AAClB,OAAO,EACH,YAAY,EACZ,kBAAkB,EAClB,6BAA6B,EAC7B,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EAC1B,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,iCAAiC,EAAE,wCAAwC,EAAE,MAAM,WAAW,CAAA"}

package/dist/types/functions/participant.d.ts

@@ -0,0 +1,58 @@
+import * as functions from "firebase-functions";
+/**
+ * Check the user's current participant status for the ceremony.
+ * @notice this cloud function has several tasks:
+ * 1) Check if the authenticated user is a participant
+ * 1.A) If not, register it has new participant for the ceremony.
+ * 1.B) Otherwise:
+ * 2.A) Check if already contributed to all circuits or,
+ * 3.A) If already contributed, return false
+ * 2.B) Check if it has a timeout in progress
+ * 3.B) If timeout expired, allows the participant to resume the contribution and remove stale/outdated
+ * temporary data.
+ * 3.C) Otherwise, return false.
+ * 2.C) Check if there are temporary stale contribution data if the contributor has interrupted the contribution
+ * while completing the `COMPUTING` step and, if any, delete them.
+ * 1.D) If no timeout / participant already exist, just return true.
+ * @dev true when the participant can participate (1.A, 3.B, 1.D); otherwise false.
+ */
+export declare const checkParticipantForCeremony: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Progress the participant to the next circuit preparing for the next contribution.
+ * @dev The participant can progress if and only if:
+ * 1) the participant has just been registered and is waiting to be queued for the first contribution (contributionProgress = 0 && status = WAITING).
+ * 2) the participant has just finished the contribution for a circuit (contributionProgress != 0 && status = CONTRIBUTED && contributionStep = COMPLETED).
+ */
+export declare const progressToNextCircuitForContribution: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Progress the participant to the next contribution step while contributing to a circuit.
+ * @dev this cloud function must enforce the order among the contribution steps:
+ * 1) Downloading the last contribution.
+ * 2) Computing the next contribution.
+ * 3) Uploading the next contribution.
+ * 4) Requesting the verification to the cloud function `verifycontribution`.
+ * 5) Completed contribution computation and verification.
+ */
+export declare const progressToNextContributionStep: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Write the information about current contribution hash and computation time for the current contributor.
+ * @dev enable the current contributor to resume a contribution from where it had left off.
+ */
+export declare const permanentlyStoreCurrentContributionTimeAndHash: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Write temporary information about the unique identifier about the opened multi-part upload to eventually resume the contribution.
+ * @dev enable the current contributor to resume a multi-part upload from where it had left off.
+ */
+export declare const temporaryStoreCurrentContributionMultiPartUploadId: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Write temporary information about the etags and part numbers for each uploaded chunk in order to make the upload resumable from last chunk.
+ * @dev enable the current contributor to resume a multi-part upload from where it had left off.
+ */
+export declare const temporaryStoreCurrentContributionUploadedChunkData: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Prepare the coordinator for the finalization of the ceremony.
+ * @dev checks that the ceremony is closed (= CLOSED) and that the coordinator has already +
+ * contributed to every selected ceremony circuits (= DONE).
+ */
+export declare const checkAndPrepareCoordinatorForFinalization: functions.HttpsFunction & functions.Runnable<any>;
+//# sourceMappingURL=participant.d.ts.map

package/dist/types/functions/participant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"participant.d.ts","sourceRoot":"","sources":["../../../src/functions/participant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AA4B/C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,2BAA2B,mDA2HlC,CAAA;AAEN;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,mDA+C3C,CAAA;AAEN;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,mDAyDrC,CAAA;AAEN;;;GAGG;AACH,eAAO,MAAM,8CAA8C,mDAqDtD,CAAA;AAEL;;;GAGG;AACH,eAAO,MAAM,kDAAkD,mDAgD1D,CAAA;AAEL;;;GAGG;AACH,eAAO,MAAM,kDAAkD,mDAqD1D,CAAA;AAEL;;;;GAIG;AACH,eAAO,MAAM,yCAAyC,mDAuDhD,CAAA"}

package/dist/types/functions/storage.d.ts

@@ -0,0 +1,37 @@
+import * as functions from "firebase-functions";
+/**
+ * Create a new AWS S3 bucket for a particular ceremony.
+ * @notice the S3 bucket is used to store all the ceremony artifacts and contributions.
+ */
+export declare const createBucket: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Check if a specified object exist in a given AWS S3 bucket.
+ * @returns <Promise<boolean>> - true if the object exist in the given bucket; otherwise false.
+ */
+export declare const checkIfObjectExist: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Return a pre-signed url for a given object contained inside the provided AWS S3 bucket in order to perform a GET request.
+ * @notice the pre-signed url has a predefined expiration expressed in seconds inside the environment
+ * configuration of the `backend` package. The value should match the configuration of `phase2cli` package
+ * environment to avoid inconsistency between client request and CF.
+ */
+export declare const generateGetObjectPreSignedUrl: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Start a new multi-part upload for a specific object in the given AWS S3 bucket.
+ * @notice this operation can be performed by either an authenticated participant or a coordinator.
+ */
+export declare const startMultiPartUpload: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Generate a new pre-signed url for each chunk related to a started multi-part upload.
+ * @notice this operation can be performed by either an authenticated participant or a coordinator.
+ * the pre-signed url has a predefined expiration expressed in seconds inside the environment
+ * configuration of the `backend` package. The value should match the configuration of `phase2cli` package
+ * environment to avoid inconsistency between client request and CF.
+ */
+export declare const generatePreSignedUrlsParts: functions.HttpsFunction & functions.Runnable<any>;
+/**
+ * Complete a multi-part upload for a specific object in the given AWS S3 bucket.
+ * @notice this operation can be performed by either an authenticated participant or a coordinator.
+ */
+export declare const completeMultiPartUpload: functions.HttpsFunction & functions.Runnable<any>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/types/functions/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/functions/storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAiI/C;;;GAGG;AACH,eAAO,MAAM,YAAY,mDAgGnB,CAAA;AAEN;;;GAGG;AACH,eAAO,MAAM,kBAAkB,mDAgDzB,CAAA;AAEN;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,mDAyCpC,CAAA;AAEN;;;GAGG;AACH,eAAO,MAAM,oBAAoB,mDA2D3B,CAAA;AAEN;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,mDAuElC,CAAA;AAEL;;;GAGG;AACH,eAAO,MAAM,uBAAuB,mDAgE9B,CAAA"}

package/dist/types/functions/timeout.d.ts

@@ -0,0 +1,26 @@
+import * as functions from "firebase-functions";
+/**
+ * Check and remove the current contributor if it doesn't complete the contribution on the specified amount of time.
+ * @dev since this cloud function is executed every minute, delay problems may occur. See issue #192 (https://github.com/quadratic-funding/mpc-phase2-suite/issues/192).
+ * @notice the reasons why a contributor may be considered blocking are many.
+ * for example due to network latency, disk availability issues, un/intentional crashes, limited hardware capabilities.
+ * the timeout mechanism (fixed/dynamic) could also influence this decision.
+ * this cloud function should check each circuit and:
+ * A) avoid timeout if there's no current contributor for the circuit.
+ * B) avoid timeout if the current contributor is the first for the circuit
+ * and timeout mechanism type is dynamic (suggestion: coordinator should be the first contributor).
+ * C) check if the current contributor is a potential blocking contributor for the circuit.
+ * D) discriminate between blocking contributor (= when downloading, computing, uploading contribution steps)
+ * or verification (= verifying contribution step) timeout types.
+ * E) execute timeout.
+ * E.1) prepare next contributor (if any).
+ * E.2) update circuit contributors waiting queue removing the current contributor.
+ * E.3) assign timeout to blocking contributor (participant doc update + timeout doc).
+ */
+export declare const checkAndRemoveBlockingContributor: functions.CloudFunction<unknown>;
+/**
+ * Resume the contributor circuit contribution from scratch after the timeout expiration.
+ * @dev The participant can resume the contribution if and only if the last timeout in progress was verified as expired (status == EXHUMED).
+ */
+export declare const resumeContributionAfterTimeoutExpiration: functions.HttpsFunction & functions.Runnable<any>;
+//# sourceMappingURL=timeout.d.ts.map

package/dist/types/functions/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../../src/functions/timeout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAuB/C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iCAAiC,kCA6MxC,CAAA;AAEN;;;GAGG;AACH,eAAO,MAAM,wCAAwC,mDAyC/C,CAAA"}

package/dist/types/functions/user.d.ts

@@ -0,0 +1,15 @@
+import * as functions from "firebase-functions";
+/**
+ * Record the authenticated user information inside the Firestore DB upon authentication.
+ * @dev the data is recorded in a new document in the `users` collection.
+ * @notice this method is automatically triggered upon user authentication in the Firebase app
+ * which uses the Firebase Authentication service.
+ */
+export declare const registerAuthUser: functions.CloudFunction<import("firebase-admin/auth").UserRecord>;
+/**
+ * Set custom claims for role-based access control on the newly created user.
+ * @notice this method is automatically triggered upon user authentication in the Firebase app
+ * which uses the Firebase Authentication service.
+ */
+export declare const processSignUpWithCustomClaims: functions.CloudFunction<import("firebase-admin/auth").UserRecord>;
+//# sourceMappingURL=user.d.ts.map

package/dist/types/functions/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../src/functions/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAW/C;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,mEAuFvB,CAAA;AACN;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,mEA+BpC,CAAA"}

package/dist/types/lib/errors.d.ts

@@ -0,0 +1,75 @@
+import * as functions from "firebase-functions";
+import { FunctionsErrorCode, HttpsError } from "firebase-functions/v1/https";
+import { LogLevel } from "../types/enums";
+/**
+ * Create a new custom HTTPs error for cloud functions.
+ * @notice the set of Firebase Functions status codes. The codes are the same at the
+ * ones exposed by {@link https://github.com/grpc/grpc/blob/master/doc/statuscodes.md | gRPC}.
+ * @param errorCode <FunctionsErrorCode> - the set of possible error codes.
+ * @param message <string> - the error messge.
+ * @param [details] <string> - the details of the error (optional).
+ * @returns <HttpsError>
+ */
+export declare const makeError: (errorCode: FunctionsErrorCode, message: string, details?: string) => HttpsError;
+/**
+ * Log a custom message on console using a specific level.
+ * @param message <string> - the message to be shown.
+ * @param logLevel <LogLevel> - the level of the log to be used to show the message (e.g., debug, error).
+ */
+export declare const printLog: (message: string, logLevel: LogLevel) => void;
+/**
+ * Log and throw an HTTPs error.
+ * @param error <HttpsError> - the error to be logged and thrown.
+ */
+export declare const logAndThrowError: (error: HttpsError) => never;
+/**
+ * A set of Cloud Function specific errors.
+ * @notice these are errors that happen only on specific cloud functions.
+ */
+export declare const SPECIFIC_ERRORS: {
+    SE_AUTH_NO_CURRENT_AUTH_USER: functions.auth.HttpsError;
+    SE_AUTH_SET_CUSTOM_USER_CLAIMS_FAIL: functions.auth.HttpsError;
+    SE_AUTH_USER_NOT_REPUTABLE: functions.auth.HttpsError;
+    SE_STORAGE_INVALID_BUCKET_NAME: functions.auth.HttpsError;
+    SE_STORAGE_TOO_MANY_BUCKETS: functions.auth.HttpsError;
+    SE_STORAGE_MISSING_PERMISSIONS: functions.auth.HttpsError;
+    SE_STORAGE_BUCKET_NOT_CONNECTED_TO_CEREMONY: functions.auth.HttpsError;
+    SE_STORAGE_WRONG_OBJECT_KEY: functions.auth.HttpsError;
+    SE_STORAGE_CANNOT_INTERACT_WITH_MULTI_PART_UPLOAD: functions.auth.HttpsError;
+    SE_STORAGE_DOWNLOAD_FAILED: functions.auth.HttpsError;
+    SE_STORAGE_UPLOAD_FAILED: functions.auth.HttpsError;
+    SE_STORAGE_DELETE_FAILED: functions.auth.HttpsError;
+    SE_CONTRIBUTE_NO_CEREMONY_CIRCUITS: functions.auth.HttpsError;
+    SE_CONTRIBUTE_NO_OPENED_CEREMONIES: functions.auth.HttpsError;
+    SE_CONTRIBUTE_CANNOT_PROGRESS_TO_NEXT_CIRCUIT: functions.auth.HttpsError;
+    SE_PARTICIPANT_CEREMONY_NOT_OPENED: functions.auth.HttpsError;
+    SE_PARTICIPANT_NOT_CONTRIBUTING: functions.auth.HttpsError;
+    SE_PARTICIPANT_CANNOT_STORE_PERMANENT_DATA: functions.auth.HttpsError;
+    SE_PARTICIPANT_CANNOT_STORE_TEMPORARY_DATA: functions.auth.HttpsError;
+    SE_VERIFICATION_NO_PARTICIPANT_CONTRIBUTION_DATA: functions.auth.HttpsError;
+    SE_CEREMONY_CANNOT_FINALIZE_CEREMONY: functions.auth.HttpsError;
+    SE_FINALIZE_NO_CEREMONY_CONTRIBUTIONS: functions.auth.HttpsError;
+    SE_FINALIZE_NO_FINAL_CONTRIBUTION: functions.auth.HttpsError;
+    SE_VM_NOT_RUNNING: functions.auth.HttpsError;
+    SE_VM_FAILED_COMMAND_EXECUTION: functions.auth.HttpsError;
+    SE_VM_TIMEDOUT_COMMAND_EXECUTION: functions.auth.HttpsError;
+    SE_VM_CANCELLED_COMMAND_EXECUTION: functions.auth.HttpsError;
+    SE_VM_DELAYED_COMMAND_EXECUTION: functions.auth.HttpsError;
+};
+/**
+ * A set of common errors.
+ * @notice these are errors that happen on multiple cloud functions (e.g., auth, missing data).
+ */
+export declare const COMMON_ERRORS: {
+    CM_NOT_COORDINATOR_ROLE: functions.auth.HttpsError;
+    CM_MISSING_OR_WRONG_INPUT_DATA: functions.auth.HttpsError;
+    CM_WRONG_CONFIGURATION: functions.auth.HttpsError;
+    CM_NOT_AUTHENTICATED: functions.auth.HttpsError;
+    CM_INEXISTENT_DOCUMENT: functions.auth.HttpsError;
+    CM_INEXISTENT_DOCUMENT_DATA: functions.auth.HttpsError;
+    CM_INVALID_CEREMONY_FOR_PARTICIPANT: functions.auth.HttpsError;
+    CM_NO_CIRCUIT_FOR_GIVEN_SEQUENCE_POSITION: functions.auth.HttpsError;
+    CM_INVALID_REQUEST: functions.auth.HttpsError;
+    CM_INVALID_COMMAND_EXECUTION: functions.auth.HttpsError;
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/lib/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,cAAe,kBAAkB,WAAW,MAAM,YAAY,MAAM,KAAG,UAC9B,CAAA;AAE/D;;;;GAIG;AACH,eAAO,MAAM,QAAQ,YAAa,MAAM,YAAY,QAAQ,SAqB3D,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,UAAW,UAAU,UAGjD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkI3B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;CA2CzB,CAAA"}

package/dist/types/lib/services.d.ts

@@ -0,0 +1,9 @@
+import { S3Client } from "@aws-sdk/client-s3";
+/**
+ * Return a configured and connected instance of the AWS S3 client.
+ * @dev this method check and utilize the environment variables to configure the connection
+ * w/ the S3 client.
+ * @returns <Promise<S3Client>> - the instance of the connected S3 Client instance.
+ */
+export declare const getS3Client: () => Promise<S3Client>;
+//# sourceMappingURL=services.d.ts.map

package/dist/types/lib/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../src/lib/services.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAG7C;;;;;GAKG;AACH,eAAO,MAAM,WAAW,QAAa,QAAQ,QAAQ,CAkBpD,CAAA"}

package/dist/types/lib/utils.d.ts

@@ -0,0 +1,141 @@
+import { DocumentData, QuerySnapshot, DocumentSnapshot, QueryDocumentSnapshot, WhereFilterOp } from "firebase-admin/firestore";
+import admin from "firebase-admin";
+import { CircuitDocument } from "@p0tion/actions";
+import { SSMClient } from "@aws-sdk/client-ssm";
+import { EC2Client } from "@aws-sdk/client-ec2";
+/**
+ * Get a specific document from database.
+ * @dev this method differs from the one in the `actions` package because we need to use
+ * the admin SDK here; therefore the Firestore instances are not interchangeable between admin
+ * and user instance.
+ * @param collection <string> - the name of the collection.
+ * @param documentId <string> - the unique identifier of the document in the collection.
+ * @returns <Promise<DocumentSnapshot<DocumentData>>> - the requested document w/ relative data.
+ */
+export declare const getDocumentById: (collection: string, documentId: string) => Promise<DocumentSnapshot<DocumentData>>;
+/**
+ * Get the current server timestamp.
+ * @dev the value is in milliseconds.
+ * @returns <number> - the timestamp of the server (ms).
+ */
+export declare const getCurrentServerTimestampInMillis: () => number;
+/**
+ * Interrupt the current execution for a specified amount of time.
+ * @param ms <number> - the amount of time expressed in milliseconds.
+ */
+export declare const sleep: (ms: number) => Promise<void>;
+/**
+ * Query for ceremony circuits.
+ * @notice the order by sequence position is fundamental to maintain parallelism among contributions for different circuits.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @returns Promise<Array<FirebaseDocumentInfo>> - the ceremony' circuits documents ordered by sequence position.
+ */
+export declare const getCeremonyCircuits: (ceremonyId: string) => Promise<Array<QueryDocumentSnapshot<DocumentData>>>;
+/**
+ * Query for ceremony circuit contributions.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param circuitId <string> - the unique identifier of the circuitId.
+ * @returns Promise<Array<FirebaseDocumentInfo>> - the contributions of the ceremony circuit.
+ */
+export declare const getCeremonyCircuitContributions: (ceremonyId: string, circuitId: string) => Promise<Array<QueryDocumentSnapshot<DocumentData>>>;
+/**
+ * Query not expired timeouts.
+ * @notice a timeout is considered valid (aka not expired) if and only if the timeout end date
+ * value is less than current timestamp.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param participantId <string> - the unique identifier of the participant.
+ * @returns <Promise<QuerySnapshot<DocumentData>>>
+ */
+export declare const queryNotExpiredTimeouts: (ceremonyId: string, participantId: string) => Promise<QuerySnapshot<DocumentData>>;
+/**
+ * Query for opened ceremonies.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @returns <Promise<Array<FirebaseDocumentInfo>>>
+ */
+export declare const queryOpenedCeremonies: () => Promise<Array<QueryDocumentSnapshot<DocumentData>>>;
+/**
+ * Get ceremony circuit document by sequence position.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param sequencePosition <number> - the sequence position of the circuit.
+ * @returns Promise<QueryDocumentSnapshot<DocumentData>>
+ */
+export declare const getCircuitDocumentByPosition: (ceremonyId: string, sequencePosition: number) => Promise<QueryDocumentSnapshot<DocumentData>>;
+/**
+ * Create a temporary file path in the virtual memory of the cloud function.
+ * @dev useful when downloading files from AWS S3 buckets for processing within cloud functions.
+ * @param completeFilename <string> - the complete file name (name + ext).
+ * @returns <string> - the path to the local temporary location.
+ */
+export declare const createTemporaryLocalPath: (completeFilename: string) => string;
+/**
+ * Download an artifact from the AWS S3 bucket.
+ * @dev this method uses streams.
+ * @param bucketName <string> - the name of the bucket.
+ * @param objectKey <string> - the unique key to identify the object inside the given AWS S3 bucket.
+ * @param localFilePath <string> - the local path where the file will be stored.
+ */
+export declare const downloadArtifactFromS3Bucket: (bucketName: string, objectKey: string, localFilePath: string) => Promise<void>;
+/**
+ * Upload a new artifact to the AWS S3 bucket.
+ * @dev this method uses streams.
+ * @param bucketName <string> - the name of the bucket.
+ * @param objectKey <string> - the unique key to identify the object inside the given AWS S3 bucket.
+ * @param localFilePath <string> - the local path where the file to be uploaded is stored.
+ */
+export declare const uploadFileToBucket: (bucketName: string, objectKey: string, localFilePath: string, isPublic?: boolean) => Promise<void>;
+export declare const uploadFileToBucketNoFile: (bucketName: string, objectKey: string, data: string, isPublic?: boolean) => Promise<void>;
+/**
+ * Upload an artifact from the AWS S3 bucket.
+ * @param bucketName <string> - the name of the bucket.
+ * @param objectKey <string> - the unique key to identify the object inside the given AWS S3 bucket.
+ */
+export declare const deleteObject: (bucketName: string, objectKey: string) => Promise<void>;
+/**
+ * Query ceremonies by state and (start/end) date value.
+ * @param state <string> - the state of the ceremony.
+ * @param needToCheckStartDate <boolean> - flag to discriminate when to check startDate (true) or endDate (false).
+ * @param check <WhereFilerOp> - the type of filter (query check - e.g., '<' or '>').
+ * @returns <Promise<admin.firestore.QuerySnapshot<admin.firestore.DocumentData>>> - the queried ceremonies after filtering operation.
+ */
+export declare const queryCeremoniesByStateAndDate: (state: string, needToCheckStartDate: boolean, check: WhereFilterOp) => Promise<admin.firestore.QuerySnapshot<admin.firestore.DocumentData>>;
+/**
+ * Return the document associated with the final contribution for a ceremony circuit.
+ * @dev this method is useful during ceremony finalization.
+ * @param ceremonyId <string> -
+ * @param circuitId <string> -
+ * @returns Promise<QueryDocumentSnapshot<DocumentData>> - the final contribution for the ceremony circuit.
+ */
+export declare const getFinalContribution: (ceremonyId: string, circuitId: string) => Promise<QueryDocumentSnapshot<DocumentData>>;
+/**
+ * Helper function to HTML encode circuit data.
+ * @param circuitDocument <CircuitDocument> - the circuit document to be encoded.
+ * @returns <CircuitDocument> - the circuit document encoded.
+ */
+export declare const htmlEncodeCircuitData: (circuitDocument: CircuitDocument) => CircuitDocument;
+/**
+ * Fetch the variables related to GitHub anti-sybil checks
+ * @returns <any> - the GitHub variables.
+ */
+export declare const getGitHubVariables: () => any;
+/**
+ * Fetch the variables related to EC2 verification
+ * @returns <any> - the AWS EC2 variables.
+ */
+export declare const getAWSVariables: () => any;
+/**
+ * Create an EC2 client object
+ * @returns <Promise<EC2Client>> an EC2 client
+ */
+export declare const createEC2Client: () => Promise<EC2Client>;
+/**
+ * Create an SSM client object
+ * @returns <Promise<SSMClient>> an SSM client
+ */
+export declare const createSSMClient: () => Promise<SSMClient>;
+/**
+ * Get the instance id of the EC2 instance associated with the circuit
+ * @param circuitId <string> - the circuit id
+ * @returns <Promise<string>> - the EC2 instance id
+ */
+export declare const getEC2InstanceId: (circuitId: string) => Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EAErB,aAAa,EAChB,MAAM,0BAA0B,CAAA;AACjC,OAAO,KAAK,MAAM,gBAAgB,CAAA;AAWlC,OAAO,EAOH,eAAe,EAClB,MAAM,iBAAiB,CAAA;AAIxB,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAM/C;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,eACZ,MAAM,cACN,MAAM,KACnB,QAAQ,iBAAiB,YAAY,CAAC,CASxC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,iCAAiC,QAAO,MAAoC,CAAA;AAEzF;;;GAGG;AACH,eAAO,MAAM,KAAK,OAAc,MAAM,KAAG,QAAQ,IAAI,CAAmB,CAAA;AAExE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,eAAsB,MAAM,KAAG,QAAQ,MAAM,sBAAsB,YAAY,CAAC,CAAC,CAYhH,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,eAC5B,MAAM,aACP,MAAM,KAClB,QAAQ,MAAM,sBAAsB,YAAY,CAAC,CAAC,CAUpD,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,eACpB,MAAM,iBACH,MAAM,KACtB,QAAQ,cAAc,YAAY,CAAC,CASrC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,QAAa,QAAQ,MAAM,sBAAsB,YAAY,CAAC,CAAC,CAWhG,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,eACzB,MAAM,oBACA,MAAM,KACzB,QAAQ,sBAAsB,YAAY,CAAC,CAY7C,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,qBAAsB,MAAM,KAAG,MAAkD,CAAA;AAEtH;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,eAAsB,MAAM,aAAa,MAAM,iBAAiB,MAAM,kBA6B9G,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,eACf,MAAM,aACP,MAAM,iBACF,MAAM,aACX,OAAO,kBA4BpB,CAAA;AAED,eAAO,MAAM,wBAAwB,eACrB,MAAM,aACP,MAAM,QACX,MAAM,aACF,OAAO,kBAyBpB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,eAAsB,MAAM,aAAa,MAAM,kBAWvE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,UAC/B,MAAM,wBACS,OAAO,SACtB,aAAa,KACrB,QAAQ,MAAM,SAAS,cAAc,CAAC,MAAM,SAAS,aAAa,CAAC,CAYxD,CAAA;AAEd;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,eACjB,MAAM,aACP,MAAM,KAClB,QAAQ,sBAAsB,YAAY,CAAC,CAgB7C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,oBAAqB,eAAe,KAAG,eAKvE,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAO,GAarC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAO,GAkBlC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAa,QAAQ,SAAS,CAYzD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAa,QAAQ,SAAS,CAYzD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,cAAqB,MAAM,KAAG,QAAQ,MAAM,CAQxE,CAAA"}

package/dist/types/types/enums.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Log levels.
+ * @notice useful to discriminate the log level for message printing.
+ * @enum {string}
+ */
+export declare enum LogLevel {
+    INFO = "INFO",
+    DEBUG = "DEBUG",
+    WARN = "WARN",
+    ERROR = "ERROR",
+    LOG = "LOG"
+}
+//# sourceMappingURL=enums.d.ts.map

package/dist/types/types/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../src/types/enums.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oBAAY,QAAQ;IAChB,IAAI,SAAS;IACb,KAAK,UAAU;IACf,IAAI,SAAS;IACb,KAAK,UAAU;IACf,GAAG,QAAQ;CACd"}