@devtion/devcli 0.0.0-7e983e3

package/dist/types/commands/auth.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { Verification } from "@octokit/auth-oauth-device/dist-types/types.js";
+/**
+ * Custom countdown which throws an error when expires.
+ * @param expirationInSeconds <number> - the expiration time in seconds.
+ */
+export declare const expirationCountdownForGithubOAuth: (expirationInSeconds: number) => void;
+/**
+ * Callback to manage the data requested for Github OAuth2.0 device flow.
+ * @param verification <Verification> - the data from Github OAuth2.0 device flow.
+ */
+export declare const onVerification: (verification: Verification) => Promise<void>;
+/**
+ * Return the Github OAuth 2.0 token using manual Device Flow authentication process.
+ * @param clientId <string> - the client id for the CLI OAuth app.
+ * @returns <string> the Github OAuth 2.0 token.
+ */
+export declare const executeGithubDeviceFlow: (clientId: string) => Promise<string>;
+/**
+ * Auth command.
+ * @notice The auth command allows a user to make the association of their Github account with the CLI by leveraging OAuth 2.0 as an authentication mechanism.
+ * @dev Under the hood, the command handles a manual Device Flow following the guidelines in the Github documentation.
+ */
+declare const auth: () => Promise<void>;
+export default auth;

package/dist/types/commands/clean.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Clean command.
+ */
+declare const clean: () => Promise<void>;
+export default clean;

package/dist/types/commands/contribute.d.ts

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import { Contribution, ContributionValidity, FirebaseDocumentInfo } from "@p0tion/actions";
+import { DocumentSnapshot, DocumentData, Firestore } from "firebase/firestore";
+import { Functions } from "firebase/functions";
+/**
+ * Return the verification result for latest contribution.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param circuitId <string> - the unique identifier of the circuit.
+ * @param participantId <string> - the unique identifier of the contributor.
+ */
+export declare const getLatestVerificationResult: (firestoreDatabase: Firestore, ceremonyId: string, circuitId: string, participantId: string) => Promise<void>;
+/**
+ * Generate a ready-to-share tweet on public attestation.
+ * @param ceremonyTitle <string> - the title of the ceremony.
+ * @param gistUrl <string> - the Github public attestation gist url.
+ */
+export declare const handleTweetGeneration: (ceremonyTitle: string, gistUrl: string) => Promise<void>;
+/**
+ * Display if a set of contributions computed for a circuit is valid/invalid.
+ * @param contributionsWithValidity <Array<ContributionValidity>> - list of contributor contributions together with contribution validity.
+ */
+export declare const displayContributionValidity: (contributionsWithValidity: Array<ContributionValidity>) => void;
+/**
+ * Display and manage data necessary when participant has already made the contribution for all circuits of a ceremony.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param circuits <Array<FirebaseDocumentInfo>> - the array of ceremony circuits documents.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param participantId <string> - the unique identifier of the contributor.
+ */
+export declare const handleContributionValidity: (firestoreDatabase: Firestore, circuits: Array<FirebaseDocumentInfo>, ceremonyId: string, participantId: string) => Promise<void>;
+/**
+ * Display and manage data necessary when participant would like to contribute but there is still an on-going timeout.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param participantId <string> - the unique identifier of the contributor.
+ * @param participantContributionProgress <number> - the progress in the contribution of the various circuits of the ceremony.
+ * @param wasContributing <boolean> - flag to discriminate between participant currently contributing (true) or not (false).
+ */
+export declare const handleTimedoutMessageForContributor: (firestoreDatabase: Firestore, participantId: string, ceremonyId: string, participantContributionProgress: number, wasContributing: boolean) => Promise<void>;
+/**
+ * Check if the participant has enough disk space available before joining the waiting queue
+ * for the computing the next circuit contribution.
+ * @param cloudFunctions <Functions> - the instance of the Firebase cloud functions for the application.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param circuitSequencePosition <number> - the position of the circuit in the sequence for contribution.
+ * @param circuitZkeySizeInBytes <number> - the size in bytes of the circuit zKey.
+ * @param isResumingAfterTimeout <boolean> - flag to discriminate between resuming after a timeout expiration (true) or progressing to next contribution (false).
+ * @param providerUserId <string> - the external third-party provider user identifier.
+ * @return <Promise<boolean>> - true when the contributor would like to generate the attestation and do not provide any further contribution to the ceremony; otherwise false.
+ */
+export declare const handleDiskSpaceRequirementForNextContribution: (cloudFunctions: Functions, ceremonyId: string, circuitSequencePosition: number, circuitZkeySizeInBytes: number, isResumingAfterTimeout: boolean, providerUserId: string) => Promise<boolean>;
+/**
+ * Generate the public attestation for the contributor.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param circuits <Array<FirebaseDocumentInfo>> - the array of ceremony circuits documents.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param participantId <string> - the unique identifier of the contributor.
+ * @param participantContributions <Array<Co> - the document data of the participant.
+ * @param contributorIdentifier <string> - the identifier of the contributor (handle, name, uid).
+ * @param ceremonyName <string> - the name of the ceremony.
+ * @returns <Promise<string>> - the public attestation.
+ */
+export declare const generatePublicAttestation: (firestoreDatabase: Firestore, circuits: Array<FirebaseDocumentInfo>, ceremonyId: string, participantId: string, participantContributions: Array<Contribution>, contributorIdentifier: string, ceremonyName: string) => Promise<string>;
+/**
+ * Generate a public attestation for a contributor, publish the attestation as gist, and prepare a new ready-to-share tweet about ceremony participation.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param circuits <Array<FirebaseDocumentInfo>> - the array of ceremony circuits documents.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param participantId <string> - the unique identifier of the contributor.
+ * @param participantContributions <Array<Co> - the document data of the participant.
+ * @param contributorIdentifier <string> - the identifier of the contributor (handle, name, uid).
+ * @param ceremonyName <string> - the name of the ceremony.
+ * @param ceremonyPrefix <string> - the prefix of the ceremony.
+ * @param participantAccessToken <string> - the access token of the participant.
+ */
+export declare const handlePublicAttestation: (firestoreDatabase: Firestore, circuits: Array<FirebaseDocumentInfo>, ceremonyId: string, participantId: string, participantContributions: Array<Contribution>, contributorIdentifier: string, ceremonyName: string, ceremonyPrefix: string, participantAccessToken: string) => Promise<void>;
+/**
+ * Listen to circuit document changes.
+ * @notice the circuit is the one for which the participant wants to contribute.
+ * @dev display custom messages in order to make the participant able to follow what's going while waiting in the queue.
+ * Also, this listener use another listener for the current circuit contributor in order to inform the waiting participant about the current contributor's progress.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param participantId <string> - the unique identifier of the participant.
+ * @param circuit <FirebaseDocumentInfo> - the Firestore document info about the circuit.
+ */
+export declare const listenToCeremonyCircuitDocumentChanges: (firestoreDatabase: Firestore, ceremonyId: string, participantId: string, circuit: FirebaseDocumentInfo) => void;
+/**
+ * Listen to current authenticated participant document changes.
+ * @dev this is the core business logic related to the execution of the contribute command.
+ * Basically, the command follows the updates of circuit waiting queue, participant status and contribution steps,
+ * while covering aspects regarding memory requirements, contribution completion or resumability, interaction w/ cloud functions, and so on.
+ * @notice in order to compute a contribute for each circuit, this method follows several steps:
+ * 1) Checking participant memory availability on root disk before joining for the first contribution (circuit having circuitPosition = 1).
+ * 2) Check if the participant has not completed the contributions for every circuit or has just finished contributing.
+ * 3) If (2) is true:
+ *  3.A) Check if the participant switched to `WAITING` as contribution status.
+ *      3.A.1) if true; display circuit waiting queue updates to the participant (listener to circuit document changes).
+ *      3.A.2) otherwise; do nothing and continue with other checks.
+ *  3.B) Check if the participant switched to `CONTRIBUTING` status. The participant must be the current contributor for the circuit w/ a resumable contribution step.
+ *      3.B.1) if true; start or resume the contribution from last contribution step.
+ *      3.B.2) otherwise; do nothing and continue with other checks.
+ *  3.C) Check if the current contributor is resuming from the "VERIFYING" contribution step.
+ *      3.C.1) if true; display previous completed steps and wait for verification results.
+ *      3.C.2) otherwise; do nothing and continue with other checks.
+ *  3.D) Check if the 'verifycontribution' cloud function has successfully completed the execution.
+ *      3.D.1) if true; get and display contribution verification results.
+ *      3.D.2) otherwise; do nothing and continue with other checks.
+ *  3.E) Check if the participant experiences a timeout while contributing.
+ *      3.E.1) if true; display timeout message and gracefully terminate.
+ *      3.E.2) otherwise; do nothing and continue with other checks.
+ *  3.F) Check if the participant has completed the contribution or is trying to resume the contribution after timeout expiration.
+ *      3.F.1) if true; check the memory requirement for next/current (completed/resuming) contribution while
+ *             handling early interruption of contributions resulting in a final public attestation generation.
+ *             (this allows a user to stop their contributions to a certain circuit X if their cannot provide/do not own
+ *              an adequate amount of memory for satisfying the memory requirements of the next/current contribution).
+ *      3.F.2) otherwise; do nothing and continue with other checks.
+ *  3.G) Check if the participant has already contributed to every circuit when running the command.
+ *      3.G.1) if true; generate public final attestation and gracefully exit.
+ *      3.G.2) otherwise; do nothing
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param cloudFunctions <Functions> - the instance of the Firebase cloud functions for the application.
+ * @param participant <DocumentSnapshot<DocumentData>> - the Firestore document of the participant.
+ * @param ceremony <FirebaseDocumentInfo> - the Firestore document info about the selected ceremony.
+ * @param entropy <string> - the random value (aka toxic waste) entered by the participant for the contribution.
+ * @param providerUserId <string> - the unique provider user identifier associated to the authenticated account.
+ * @param accessToken <string> - the Github token generated through the Device Flow process.
+ */
+export declare const listenToParticipantDocumentChanges: (firestoreDatabase: Firestore, cloudFunctions: Functions, participant: DocumentSnapshot<DocumentData>, ceremony: FirebaseDocumentInfo, entropy: string, providerUserId: string, accessToken: string) => Promise<void>;
+/**
+ * Contribute command.
+ * @notice The contribute command allows an authenticated user to become a participant (contributor) to the selected ceremony by providing the
+ * entropy (toxic waste) for the contribution.
+ * @dev For proper execution, the command requires the user to be authenticated with Github account (run auth command first) in order to
+ * handle sybil-resistance and connect to Github APIs to publish the gist containing the public attestation.
+ */
+declare const contribute: (opt: any) => Promise<void>;
+export default contribute;

package/dist/types/commands/finalize.d.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { FirebaseDocumentInfo } from "@p0tion/actions";
+import { Functions } from "firebase/functions";
+import { Firestore } from "firebase/firestore";
+/**
+ * Export and store on the ceremony bucket the verification key for the given final contribution.
+ * @param cloudFunctions <Functions> - the instance of the Firebase cloud functions for the application.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ * @param finalZkeyLocalFilePath <string> - the local file path of the final zKey.
+ * @param verificationKeyLocalFilePath <string> - the local file path of the verification key.
+ * @param verificationKeyStorageFilePath <string> - the storage file path of the verification key.
+ */
+export declare const handleVerificationKey: (cloudFunctions: Functions, bucketName: string, finalZkeyLocalFilePath: string, verificationKeyLocalFilePath: string, verificationKeyStorageFilePath: string) => Promise<void>;
+/**
+ * Derive and store on the ceremony bucket the Solidity Verifier smart contract for the given final contribution.
+ * @param cloudFunctions <Functions> - the instance of the Firebase cloud functions for the application.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ * @param finalZkeyLocalFilePath <string> - the local file path of the final zKey.
+ * @param verifierContractLocalFilePath <string> - the local file path of the verifier smart contract.
+ * @param verifierContractStorageFilePath <string> - the storage file path of the verifier smart contract.
+ */
+export declare const handleVerifierSmartContract: (cloudFunctions: Functions, bucketName: string, finalZkeyLocalFilePath: string, verifierContractLocalFilePath: string, verifierContractStorageFilePath: string) => Promise<void>;
+/**
+ * Handle the process of finalizing a ceremony circuit.
+ * @dev this process results in the extraction of the final ceremony artifacts for the calculation and verification of proofs.
+ * @notice this method must enforce the order among these steps:
+ * 1) Compute the final contribution (zKey).
+ * 2) Extract the verification key (vKey).
+ * 3) Extract the Verifier smart contract (.sol).
+ * 4) Upload the artifacts in the AWS S3 storage.
+ * 5) Complete the final contribution data w/ artifacts references and hashes (cloud function).
+ * @param cloudFunctions <Functions> - the instance of the Firebase cloud functions for the application.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param ceremony <FirebaseDocumentInfo> - the Firestore document of the ceremony.
+ * @param circuit <FirebaseDocumentInfo> - the Firestore document of the ceremony circuit.
+ * @param participant <FirebaseDocumentInfo> - the Firestore document of the participant (coordinator).
+ * @param beacon <string> - the value used to compute the final contribution while finalizing the ceremony.
+ * @param coordinatorIdentifier <string> - the identifier of the coordinator.
+ */
+export declare const handleCircuitFinalization: (cloudFunctions: Functions, firestoreDatabase: Firestore, ceremony: FirebaseDocumentInfo, circuit: FirebaseDocumentInfo, participant: FirebaseDocumentInfo, beacon: string, coordinatorIdentifier: string) => Promise<void>;
+/**
+ * Finalize command.
+ * @notice The finalize command allows a coordinator to finalize a Trusted Setup Phase 2 ceremony by providing the final beacon,
+ * computing the final zKeys and extracting the Verifier Smart Contract + Verification Keys per each ceremony circuit.
+ * anyone could use the final zKey to create a proof and everyone else could verify the correctness using the
+ * related verification key (off-chain) or Verifier smart contract (on-chain).
+ * @dev For proper execution, the command requires the coordinator to be authenticated with a GitHub account (run auth command first) in order to
+ * handle sybil-resistance and connect to GitHub APIs to publish the gist containing the final public attestation.
+ */
+declare const finalize: () => Promise<void>;
+export default finalize;

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

@@ -0,0 +1,9 @@
+export { default as setup } from "./setup.js";
+export { default as auth } from "./auth.js";
+export { default as contribute } from "./contribute.js";
+export { default as observe } from "./observe.js";
+export { default as finalize } from "./finalize.js";
+export { default as clean } from "./clean.js";
+export { default as logout } from "./logout.js";
+export { default as validate } from "./validate.js";
+export { default as listCeremonies } from "./listCeremonies.js";

package/dist/types/commands/listCeremonies.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Validate ceremony setup command.
+ */
+declare const listCeremonies: () => Promise<never>;
+export default listCeremonies;

package/dist/types/commands/logout.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Logout command.
+ */
+declare const logout: () => Promise<void>;
+export default logout;

package/dist/types/commands/observe.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { FirebaseDocumentInfo } from "@p0tion/actions";
+import { Firestore } from "firebase/firestore";
+/**
+ * Clean cursor lines from current position back to root (default: zero).
+ * @param currentCursorPos - the current position of the cursor.
+ * @returns <number>
+ */
+export declare const cleanCursorPosBackToRoot: (currentCursorPos: number) => number;
+/**
+ * Show the latest updates for the given circuit.
+ * @param firestoreDatabase <Firestore> - the Firestore database to query from.
+ * @param ceremony <FirebaseDocumentInfo> - the Firebase document containing info about the ceremony.
+ * @param circuit <FirebaseDocumentInfo> - the Firebase document containing info about the circuit.
+ * @returns Promise<number> return the current position of the cursor (i.e., number of lines displayed).
+ */
+export declare const displayLatestCircuitUpdates: (firestoreDatabase: Firestore, ceremony: FirebaseDocumentInfo, circuit: FirebaseDocumentInfo) => Promise<number>;
+/**
+ * Observe command.
+ */
+declare const observe: () => Promise<void>;
+export default observe;

package/dist/types/commands/setup.d.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { Functions } from "firebase/functions";
+import { CeremonyTimeoutType, CircomCompilerData, CircuitInputData, CeremonyInputData, CircuitDocument } from "@p0tion/actions";
+/**
+ * Handle whatever is needed to obtain the input data for a circuit that the coordinator would like to add to the ceremony.
+ * @param choosenCircuitFilename <string> - the name of the circuit to add.
+ * @param matchingWasmFilename <string> - the name of the circuit wasm file.
+ * @param ceremonyTimeoutMechanismType <CeremonyTimeoutType> - the type of ceremony timeout mechanism.
+ * @param sameCircomCompiler <boolean> - true, if this circuit shares with the others the <CircomCompilerData>; otherwise false.
+ * @param circuitSequencePosition <number> - the position of the circuit in the contribution queue.
+ * @param sharedCircomCompilerData <string> - version and commit hash of the Circom compiler used to compile the ceremony circuits.
+ * @returns <Promise<CircuitInputData>> - the input data of the circuit to add to the ceremony.
+ */
+export declare const getInputDataToAddCircuitToCeremony: (choosenCircuitFilename: string, matchingWasmFilename: string, ceremonyTimeoutMechanismType: CeremonyTimeoutType, sameCircomCompiler: boolean, circuitSequencePosition: number, sharedCircomCompilerData: CircomCompilerData) => Promise<CircuitInputData>;
+/**
+ * Handle the addition of one or more circuits to the ceremony.
+ * @param options <Array<string>> - list of possible circuits that can be added to the ceremony.
+ * @param ceremonyTimeoutMechanismType <CeremonyTimeoutType> - the type of ceremony timeout mechanism.
+ * @returns <Promise<Array<CircuitInputData>>> - the input data for each circuit that has been added to the ceremony.
+ */
+export declare const handleAdditionOfCircuitsToCeremony: (r1csOptions: Array<string>, wasmOptions: Array<string>, ceremonyTimeoutMechanismType: CeremonyTimeoutType) => Promise<Array<CircuitInputData>>;
+/**
+ * Print ceremony and related circuits information.
+ * @param ceremonyInputData <CeremonyInputData> - the input data of the ceremony.
+ * @param circuits <Array<CircuitDocument>> - the circuit documents associated to the circuits of the ceremony.
+ */
+export declare const displayCeremonySummary: (ceremonyInputData: CeremonyInputData, circuits: Array<CircuitDocument>) => void;
+/**
+ * Check if the smallest Powers of Tau has already been downloaded/stored in the correspondent local path
+ * @dev we are downloading the Powers of Tau file from Hermez Cryptography Phase 1 Trusted Setup.
+ * @param powers <string> - the smallest amount of powers needed for the given circuit (should be in a 'XY' stringified form).
+ * @param ptauCompleteFilename <string> - the complete file name of the powers of tau file to be downloaded.
+ * @returns <Promise<void>>
+ */
+export declare const checkAndDownloadSmallestPowersOfTau: (powers: string, ptauCompleteFilename: string) => Promise<void>;
+/**
+ * Handle the needs in terms of Powers of Tau for the selected pre-computed zKey.
+ * @notice in case there are no Powers of Tau file suitable for the pre-computed zKey (i.e., having a
+ * number of powers greater than or equal to the powers needed by the zKey), the coordinator will be asked
+ * to provide a number of powers manually, ranging from the smallest possible to the largest.
+ * @param neededPowers <number> - the smallest amount of powers needed by the zKey.
+ * @returns Promise<string, string> - the information about the choosen Powers of Tau file for the pre-computed zKey
+ * along with related powers.
+ */
+export declare const handlePreComputedZkeyPowersOfTauSelection: (neededPowers: number) => Promise<{
+    doubleDigitsPowers: string;
+    potCompleteFilename: string;
+    usePreDownloadedPoT: boolean;
+}>;
+/**
+ * Generate a brand new zKey from scratch.
+ * @param r1csLocalPathAndFileName <string> - the local complete path of the R1CS selected file.
+ * @param potLocalPathAndFileName <string> - the local complete path of the PoT selected file.
+ * @param zkeyLocalPathAndFileName <string> - the local complete path of the pre-computed zKey selected file.
+ */
+export declare const handleNewZkeyGeneration: (r1csLocalPathAndFileName: string, potLocalPathAndFileName: string, zkeyLocalPathAndFileName: string) => Promise<void>;
+/**
+ * Manage the creation of a ceremony file storage bucket.
+ * @param firebaseFunctions <Functions> - the Firebase Cloud Functions instance connected to the current application.
+ * @param ceremonyPrefix <string> - the prefix of the ceremony.
+ * @returns <Promise<string>> - the ceremony bucket name.
+ */
+export declare const handleCeremonyBucketCreation: (firebaseFunctions: Functions, ceremonyPrefix: string) => Promise<string>;
+/**
+ * Upload a circuit artifact (r1cs, WASM, ptau) to the ceremony storage.
+ * @dev this method uses a multi part upload to upload the file in chunks.
+ * @param firebaseFunctions <Functions> - the Firebase Cloud Functions instance connected to the current application.
+ * @param bucketName <string> - the ceremony bucket name.
+ * @param storageFilePath <string> - the storage (bucket) path where the file should be uploaded.
+ * @param localPathAndFileName <string> - the local file path where is located.
+ * @param completeFilename <string> - the complete filename.
+ */
+export declare const handleCircuitArtifactUploadToStorage: (firebaseFunctions: Functions, bucketName: string, storageFilePath: string, localPathAndFileName: string, completeFilename: string) => Promise<void>;
+/**
+ * Setup command.
+ * @notice The setup command allows the coordinator of the ceremony to prepare the next ceremony by interacting with the CLI.
+ * @dev For proper execution, the command must be run in a folder containing the R1CS files related to the circuits
+ * for which the coordinator wants to create the ceremony. The command will download the necessary Tau powers
+ * from Hermez's ceremony Phase 1 Reliable Setup Ceremony.
+ * @param cmd? <any> - the path to the ceremony setup file.
+ */
+declare const setup: (cmd: {
+    template?: string;
+    auth?: string;
+}) => Promise<void>;
+export default setup;

package/dist/types/commands/validate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Validate ceremony setup command.
+ */
+declare const validate: (cmd: {
+    template: string;
+    constraints?: number;
+}) => Promise<void>;
+export default validate;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -0,0 +1,60 @@
+/** Services */
+export declare const CORE_SERVICES_ERRORS: {
+    FIREBASE_DEFAULT_APP_DOUBLE_CONFIG: string;
+    FIREBASE_TOKEN_EXPIRED_REMOVED_PERMISSIONS: string;
+    FIREBASE_USER_DISABLED: string;
+    FIREBASE_FAILED_CREDENTIALS_VERIFICATION: string;
+    FIREBASE_NETWORK_ERROR: string;
+    FIREBASE_CEREMONY_NOT_OPENED: string;
+    FIREBASE_CEREMONY_NOT_CLOSED: string;
+    AWS_CEREMONY_BUCKET_CREATION: string;
+    AWS_CEREMONY_BUCKET_CANNOT_DOWNLOAD_GET_PRESIGNED_URL: string;
+};
+/** Github */
+export declare const THIRD_PARTY_SERVICES_ERRORS: {
+    GITHUB_ACCOUNT_ASSOCIATION_REJECTED: string;
+    GITHUB_SERVER_TIMEDOUT: string;
+    GITHUB_GET_GITHUB_ACCOUNT_INFO: string;
+    GITHUB_NOT_AUTHENTICATED: string;
+    GITHUB_GIST_PUBLICATION_FAILED: string;
+};
+/** Command */
+export declare const COMMAND_ERRORS: {
+    COMMAND_NOT_COORDINATOR: string;
+    COMMAND_ABORT_PROMPT: string;
+    COMMAND_ABORT_SELECTION: string;
+    COMMAND_SETUP_NO_R1CS: string;
+    COMMAND_SETUP_NO_WASM: string;
+    COMMAND_SETUP_MISMATCH_R1CS_WASM: string;
+    COMMAND_SETUP_DOWNLOAD_PTAU: string;
+    COMMAND_SETUP_ABORT: string;
+    COMMAND_CONTRIBUTE_NO_OPENED_CEREMONIES: string;
+    COMMAND_CONTRIBUTE_NO_PARTICIPANT_DATA: string;
+    COMMAND_CONTRIBUTE_WRONG_OPTION_CEREMONY: string;
+    COMMAND_CONTRIBUTE_NO_CURRENT_CONTRIBUTOR_DATA: string;
+    COMMAND_CONTRIBUTE_NO_CURRENT_CONTRIBUTOR_CONTRIBUTION: string;
+    COMMAND_CONTRIBUTE_WRONG_CURRENT_CONTRIBUTOR_CONTRIBUTION_STEP: string;
+    COMMAND_CONTRIBUTE_NO_CIRCUIT_DATA: string;
+    COMMAND_CONTRIBUTE_NO_ACTIVE_TIMEOUT_DATA: string;
+    COMMAND_CONTRIBUTE_NO_UNIQUE_ACTIVE_TIMEOUTS: string;
+    COMMAND_CONTRIBUTE_FINALIZE_NO_TRANSCRIPT_CONTRIBUTION_HASH_MATCH: string;
+    COMMAND_FINALIZED_NO_CLOSED_CEREMONIES: string;
+    COMMAND_FINALIZED_NOT_READY_FOR_FINALIZATION: string;
+};
+/** Config */
+export declare const CONFIG_ERRORS: {
+    CONFIG_GITHUB_ERROR: string;
+    CONFIG_FIREBASE_ERROR: string;
+    CONFIG_OTHER_ERROR: string;
+};
+/** Generic */
+export declare const GENERIC_ERRORS: {
+    GENERIC_ERROR_RETRIEVING_DATA: string;
+    GENERIC_COUNTDOWN_EXPIRATION: string;
+};
+/**
+ * Print an error string and gracefully terminate the process.
+ * @param err <string> - the error string to be shown.
+ * @param doExit <boolean> - when true the function terminate the process; otherwise not.
+ */
+export declare const showError: (err: string, doExit: boolean) => void;

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

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { Dirent, Stats } from "fs";
+/**
+ * Check a directory path.
+ * @param directoryPath <string> - the local path of the directory.
+ * @returns <boolean> true if the directory at given path exists, otherwise false.
+ */
+export declare const directoryExists: (directoryPath: string) => boolean;
+/**
+ * Write a new file locally.
+ * @param localFilePath <string> - the local path of the file.
+ * @param data <Buffer> - the content to be written inside the file.
+ */
+export declare const writeFile: (localFilePath: string, data: Buffer) => void;
+/**
+ * Read a new file from local folder.
+ * @param localFilePath <string> - the local path of the file.
+ */
+export declare const readFile: (localFilePath: string) => string;
+/**
+ * Get back the statistics of the provided file.
+ * @param localFilePath <string> - the local path of the file.
+ * @returns <Stats> - the metadata of the file.
+ */
+export declare const getFileStats: (localFilePath: string) => Stats;
+/**
+ * Return the sub-paths for each file stored in the given directory.
+ * @param directoryLocalPath <string> - the local path of the directory.
+ * @returns <Promise<Array<Dirent>>> - the list of sub-paths of the files contained inside the directory.
+ */
+export declare const getDirFilesSubPaths: (directoryLocalPath: string) => Promise<Array<Dirent>>;
+/**
+ * Filter all files in a directory by returning only those that match the given extension.
+ * @param directoryLocalPath <string> - the local path of the directory.
+ * @param fileExtension <string> - the file extension.
+ * @returns <Promise<Array<Dirent>>> - return the filenames of the file that match the given extension, if any
+ */
+export declare const filterDirectoryFilesByExtension: (directoryLocalPath: string, fileExtension: string) => Promise<Array<Dirent>>;
+/**
+ * Delete a directory specified at a given path.
+ * @param directoryLocalPath <string> - the local path of the directory.
+ */
+export declare const deleteDir: (directoryLocalPath: string) => void;
+/**
+ * Clean a directory specified at a given path.
+ * @param directoryLocalPath <string> - the local path of the directory.
+ */
+export declare const cleanDir: (directoryLocalPath: string) => void;
+/**
+ * Create a new directory in a specified path if not exist in that path.
+ * @param directoryLocalPath <string> - the local path of the directory.
+ */
+export declare const checkAndMakeNewDirectoryIfNonexistent: (directoryLocalPath: string) => void;
+/**
+ * Write data a local JSON file at a given path.
+ * @param localFilePath <string> - the local path of the file.
+ * @param data <JSON> - the JSON content to be written inside the file.
+ */
+export declare const writeLocalJsonFile: (filePath: string, data: JSON) => void;
+/**
+ * Return the local current project directory name.
+ * @returns <string> - the local project (e.g., dist/) directory name.
+ */
+export declare const getLocalDirname: () => string;

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

@@ -0,0 +1,110 @@
+export declare const localPaths: {
+    output: string;
+    setup: string;
+    contribute: string;
+    finalize: string;
+    pot: string;
+    zkeys: string;
+    wasm: string;
+    contributions: string;
+    transcripts: string;
+    attestations: string;
+    finalZkeys: string;
+    finalPot: string;
+    finalTranscripts: string;
+    finalAttestations: string;
+    verificationKeys: string;
+    verifierContracts: string;
+};
+/**
+ * Return the access token, if present.
+ * @returns <string | undefined> - the access token if present, otherwise undefined.
+ */
+export declare const getLocalAccessToken: () => string | unknown;
+/**
+ * Check if the access token exists in the local storage.
+ * @returns <boolean>
+ */
+export declare const checkLocalAccessToken: () => boolean;
+/**
+ * Set the access token.
+ * @param token <string> - the access token to be stored.
+ */
+export declare const setLocalAccessToken: (token: string) => void;
+/**
+ * Delete the stored access token.
+ */
+export declare const deleteLocalAccessToken: () => void;
+/**
+ * Get the complete local file path.
+ * @param cwd <string> - the current working directory path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the complete local path to the file.
+ */
+export declare const getCWDFilePath: (cwd: string, completeFilename: string) => string;
+/**
+ * Get the complete PoT file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the complete PoT path to the file.
+ */
+export declare const getPotLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the complete zKey file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the complete zKey path to the file.
+ */
+export declare const getZkeyLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the complete contribution file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the complete contribution path to the file.
+ */
+export declare const getContributionLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the contribution attestation file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the the contribution attestation path to the file.
+ */
+export declare const getAttestationLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the transcript file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the the transcript path to the file.
+ */
+export declare const getTranscriptLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the complete final zKey file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the complete final zKey path to the file.
+ */
+export declare const getFinalZkeyLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the complete final PoT file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the complete final PoT path to the file.
+ */
+export declare const getFinalPotLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the complete verification key file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the complete final verification key path to the file.
+ */
+export declare const getVerificationKeyLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the complete verifier contract file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the complete final verifier contract path to the file.
+ */
+export declare const getVerifierContractLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the complete final attestation file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the complete final final attestation path to the file.
+ */
+export declare const getFinalAttestationLocalFilePath: (completeFilename: string) => string;
+/**
+ * Get the final transcript file path.
+ * @param completeFilename <string> - the complete filename of the file (name.ext).
+ * @returns <string> - the the final transcript path to the file.
+ */
+export declare const getFinalTranscriptLocalFilePath: (completeFilename: string) => string;