@devtion/actions 0.0.0-7e983e3

package/dist/types/hardhat.config.d.ts

@@ -0,0 +1,6 @@
+import "@nomiclabs/hardhat-ethers";
+import "./src/helpers/tasks";
+import { HardhatUserConfig } from "hardhat/types/index";
+declare const config: HardhatUserConfig;
+export default config;
+//# sourceMappingURL=hardhat.config.d.ts.map

package/dist/types/hardhat.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hardhat.config.d.ts","sourceRoot":"","sources":["../../hardhat.config.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAA;AAClC,OAAO,qBAAqB,CAAA;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAEvD,QAAA,MAAM,MAAM,EAAE,iBAMb,CAAA;AAED,eAAe,MAAM,CAAA"}

package/dist/types/src/helpers/authentication.d.ts

@@ -0,0 +1,21 @@
+import { User, OAuthCredential } from "firebase/auth";
+import { FirebaseApp } from "firebase/app";
+/**
+ * Sign in w/ OAuth 2.0 token.
+ * @param firebaseApp <FirebaseApp> - the configured instance of the Firebase App in use.
+ * @param credentials <OAuthCredential> - the OAuth credential generated from token exchange.
+ */
+export declare const signInToFirebaseWithCredentials: (firebaseApp: FirebaseApp, credentials: OAuthCredential) => Promise<import("@firebase/auth").UserCredential>;
+/**
+ * Return the current authenticated user in the given Firebase Application.
+ * @param firebaseApp <FirebaseApp> - the configured instance of the Firebase App in use.
+ * @returns <User> - the object containing the data about the current authenticated user in the given Firebase application.
+ */
+export declare const getCurrentFirebaseAuthUser: (firebaseApp: FirebaseApp) => User;
+/**
+ * Check if the user can claim to be a coordinator.
+ * @param user <User> - the user to be checked.
+ * @returns Promise<boolean> - true if the user is a coordinator, false otherwise.
+ */
+export declare const isCoordinator: (user: User) => Promise<boolean>;
+//# sourceMappingURL=authentication.d.ts.map

package/dist/types/src/helpers/authentication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.d.ts","sourceRoot":"","sources":["../../../../src/helpers/authentication.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAiD,eAAe,EAAE,MAAM,eAAe,CAAA;AACpG,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE1C;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,gBAAuB,WAAW,eAAe,eAAe,qDAC1C,CAAA;AAElE;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,gBAAiB,WAAW,KAAG,IASrE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,SAAgB,IAAI,qBAI7C,CAAA"}

package/dist/types/src/helpers/constants.d.ts

@@ -0,0 +1,194 @@
+export declare const potFileDownloadMainUrl = "https://hermez.s3-eu-west-1.amazonaws.com/";
+export declare const potFilenameTemplate = "powersOfTau28_hez_final_";
+export declare const genesisZkeyIndex = "00000";
+export declare const numExpIterations = 10;
+export declare const solidityVersion = "0.8.0";
+export declare const finalContributionIndex = "final";
+export declare const verificationKeyAcronym = "vkey";
+export declare const verifierSmartContractAcronym = "verifier";
+export declare const ec2InstanceTag = "p0tionec2instance";
+export declare const vmBootstrapScriptFilename = "bootstrap.sh";
+/**
+ * Define the supported VM configuration types.
+ * @dev the VM configurations can be retrieved at https://aws.amazon.com/ec2/instance-types/
+ * The on-demand prices for the configurations can be retrieved at https://aws.amazon.com/ec2/pricing/on-demand/.
+ * @notice the price has to be intended as on-demand hourly billing usage for Linux OS
+ * VMs located in the us-east-1 region expressed in USD.
+ */
+export declare const vmConfigurationTypes: {
+    t3_large: {
+        type: string;
+        ram: number;
+        vcpu: number;
+        pricePerHour: number;
+    };
+    t3_2xlarge: {
+        type: string;
+        ram: number;
+        vcpu: number;
+        pricePerHour: number;
+    };
+    c5_9xlarge: {
+        type: string;
+        ram: number;
+        vcpu: number;
+        pricePerHour: number;
+    };
+    c5_18xlarge: {
+        type: string;
+        ram: number;
+        vcpu: number;
+        pricePerHour: number;
+    };
+    c5a_8xlarge: {
+        type: string;
+        ram: number;
+        vcpu: number;
+        pricePerHour: number;
+    };
+    c6id_32xlarge: {
+        type: string;
+        ram: number;
+        vcpu: number;
+        pricePerHour: number;
+    };
+    m6a_32xlarge: {
+        type: string;
+        ram: number;
+        vcpu: number;
+        pricePerHour: number;
+    };
+};
+/**
+ * Define the PPoT Trusted Setup ceremony output powers of tau files size (in GB).
+ * @dev the powers of tau files can be retrieved at https://github.com/weijiekoh/perpetualpowersoftau
+ */
+export declare const powersOfTauFiles: {
+    ref: string;
+    size: number;
+}[];
+/**
+ * Commonly used terms.
+ * @dev useful for creating paths, references to collections and queries, object properties, folder names, and so on.
+ */
+export declare const commonTerms: {
+    collections: {
+        users: {
+            name: string;
+            fields: {
+                creationTime: string;
+                displayName: string;
+                email: string;
+                emailVerified: string;
+                lastSignInTime: string;
+                lastUpdated: string;
+                name: string;
+                photoURL: string;
+            };
+        };
+        participants: {
+            name: string;
+            fields: {
+                contributionProgress: string;
+                contributionStartedAt: string;
+                contributionStep: string;
+                contributions: string;
+                lastUpdated: string;
+                status: string;
+                verificationStartedAt: string;
+            };
+        };
+        ceremonies: {
+            name: string;
+            fields: {
+                coordinatorId: string;
+                description: string;
+                endDate: string;
+                lastUpdated: string;
+                penalty: string;
+                prefix: string;
+                startDate: string;
+                state: string;
+                timeoutType: string;
+                title: string;
+                type: string;
+            };
+        };
+        circuits: {
+            name: string;
+            fields: {
+                avgTimings: string;
+                compiler: string;
+                description: string;
+                files: string;
+                lastUpdated: string;
+                metadata: string;
+                name: string;
+                prefix: string;
+                sequencePosition: string;
+                template: string;
+                timeoutMaxContributionWaitingTime: string;
+                waitingQueue: string;
+                zKeySizeInBytes: string;
+                verification: string;
+            };
+        };
+        contributions: {
+            name: string;
+            fields: {
+                contributionComputationTime: string;
+                files: string;
+                lastUpdated: string;
+                participantId: string;
+                valid: string;
+                verificationComputationTime: string;
+                zkeyIndex: string;
+            };
+        };
+        timeouts: {
+            name: string;
+            fields: {
+                type: string;
+                startDate: string;
+                endDate: string;
+            };
+        };
+    };
+    foldersAndPathsTerms: {
+        output: string;
+        setup: string;
+        contribute: string;
+        finalize: string;
+        pot: string;
+        zkeys: string;
+        wasm: string;
+        vkeys: string;
+        metadata: string;
+        transcripts: string;
+        attestation: string;
+        verifiers: string;
+    };
+    cloudFunctionsNames: {
+        setupCeremony: string;
+        checkParticipantForCeremony: string;
+        progressToNextCircuitForContribution: string;
+        resumeContributionAfterTimeoutExpiration: string;
+        createBucket: string;
+        generateGetObjectPreSignedUrl: string;
+        progressToNextContributionStep: string;
+        permanentlyStoreCurrentContributionTimeAndHash: string;
+        startMultiPartUpload: string;
+        temporaryStoreCurrentContributionMultiPartUploadId: string;
+        temporaryStoreCurrentContributionUploadedChunkData: string;
+        generatePreSignedUrlsParts: string;
+        completeMultiPartUpload: string;
+        checkIfObjectExist: string;
+        verifyContribution: string;
+        checkAndPrepareCoordinatorForFinalization: string;
+        finalizeCircuit: string;
+        finalizeCeremony: string;
+        downloadCircuitArtifacts: string;
+        transferObject: string;
+    };
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/types/src/helpers/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/helpers/constants.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,sBAAsB,+CAA+C,CAAA;AAElF,eAAO,MAAM,mBAAmB,6BAA6B,CAAA;AAE7D,eAAO,MAAM,gBAAgB,UAAU,CAAA;AAEvC,eAAO,MAAM,gBAAgB,KAAK,CAAA;AAElC,eAAO,MAAM,eAAe,UAAU,CAAA;AAEtC,eAAO,MAAM,sBAAsB,UAAU,CAAA;AAE7C,eAAO,MAAM,sBAAsB,SAAS,CAAA;AAE5C,eAAO,MAAM,4BAA4B,aAAa,CAAA;AAEtD,eAAO,MAAM,cAAc,sBAAsB,CAAA;AAEjD,eAAO,MAAM,yBAAyB,iBAAiB,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2ChC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;GA6G5B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuHvB,CAAA"}

package/dist/types/src/helpers/contracts.d.ts

@@ -0,0 +1,57 @@
+import { Contract, Signer } from "ethers";
+import { Firestore } from "firebase/firestore";
+import { Functions } from "firebase/functions";
+/**
+ * Formats part of a GROTH16 SNARK proof
+ * @link adapted from SNARKJS p256 function
+ * @param proofPart <any> a part of a proof to be formatted
+ * @returns <string> the formatted proof part
+ */
+export declare const p256: (proofPart: any) => any;
+/**
+ * This function formats the calldata for Solidity
+ * @link adapted from SNARKJS formatSolidityCalldata function
+ * @dev this function is supposed to be called with
+ * @dev the output of generateGROTH16Proof
+ * @param circuitInput <string[]> Inputs to the circuit
+ * @param _proof <object> Proof
+ * @returns <SolidityCalldata> The calldata formatted for Solidity
+ */
+export declare const formatSolidityCalldata: (circuitInput: string[], _proof: any) => any;
+/**
+ * Verify a GROTH16 SNARK proof on chain
+ * @param contract <Contract> The contract instance
+ * @param proof <SolidityCalldata> The calldata formatted for Solidity
+ * @returns <Promise<boolean>> Whether the proof is valid or not
+ */
+export declare const verifyGROTH16ProofOnChain: (contract: any, proof: any) => Promise<boolean>;
+/**
+ * Compiles a contract given a path
+ * @param contractPath <string> path to the verifier contract
+ * @returns <Promise<any>> the compiled contract
+ */
+export declare const compileContract: (contractPath: string) => Promise<any>;
+/**
+ * Deploy the verifier contract
+ * @param contractFactory <ContractFactory> The contract factory
+ * @returns <Promise<Contract>> The contract instance
+ */
+export declare const deployVerifierContract: (contractPath: string, signer: Signer) => Promise<Contract>;
+/**
+ * Verify a ceremony validity
+ * 1. Download all artifacts
+ * 2. Verify that the zkeys are valid
+ * 3. Extract the verifier and the vKey
+ * 4. Generate a proof and verify it locally
+ * 5. Deploy Verifier contract and verify the proof on-chain
+ * @param functions <Functions> firebase functions instance
+ * @param firestore <Firestore> firebase firestore instance
+ * @param ceremonyPrefix <string> ceremony prefix
+ * @param outputDirectory <string> output directory where to store the ceremony artifacts
+ * @param circuitInputsPath <string> path to the circuit inputs file
+ * @param verifierTemplatePath <string> path to the verifier template file
+ * @param signer <Signer> signer for contract interaction
+ * @param logger <any> logger for printing snarkjs output
+ */
+export declare const verifyCeremony: (functions: Functions, firestore: Firestore, ceremonyPrefix: string, outputDirectory: string, circuitInputsPath: string, verifierTemplatePath: string, signer: Signer, logger?: any) => Promise<void>;
+//# sourceMappingURL=contracts.d.ts.map

package/dist/types/src/helpers/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../src/helpers/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAmB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE1D,OAAO,EAAE,SAAS,EAAS,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAgB9C;;;;;GAKG;AACH,eAAO,MAAM,IAAI,cAAe,GAAG,QAKlC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,iBAAkB,MAAM,EAAE,UAAU,GAAG,KAAG,GAwB5E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,aAAoB,GAAG,SAAS,GAAG,KAAG,QAAQ,OAAO,CAG1F,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,iBAAwB,MAAM,KAAG,QAAQ,GAAG,CA6BvE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,iBAAwB,MAAM,UAAU,MAAM,KAAG,QAAQ,QAAQ,CAOnG,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,cACZ,SAAS,aACT,SAAS,kBACJ,MAAM,mBACL,MAAM,qBACJ,MAAM,wBACH,MAAM,UACpB,MAAM,WACL,GAAG,KACb,QAAQ,IAAI,CAkHd,CAAA"}

package/dist/types/src/helpers/crypto.d.ts

@@ -0,0 +1,27 @@
+import fs from "fs";
+/**
+ * Converts Uint8Array to hexadecimal string.
+ * @param buffer arbritrary length of data
+ * @returns hexadecimal string
+ */
+export declare const toHex: (buffer: Uint8Array) => string;
+/**
+ * Get 512 bit blake hash of the contents of given path.
+ * @param data buffer or hexadecimal string
+ * @returns 64 byte hexadecimal string
+ */
+export declare const blake512FromPath: (path: fs.PathLike) => Promise<string>;
+/**
+ * Return the SHA256 hash (HEX format) of a given value
+ * @param value <string> - the value to be hashed.
+ * @returns <string> - the HEX format of the SHA256 hash of the given value
+ */
+export declare const computeSHA256ToHex: (value: string) => string;
+/**
+ * Helper function that can be used to compare whether two files' hashes are equal or not.
+ * @param path1 <string> Path to the first file.
+ * @param path2 <string> Path to the second file.
+ * @returns <Promise<boolean>> Whether the files are equal or not.
+ */
+export declare const compareHashes: (path1: string, path2: string) => Promise<boolean>;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/types/src/helpers/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../../src/helpers/crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAA;AASnB;;;;GAIG;AACH,eAAO,MAAM,KAAK,WAAY,UAAU,KAAG,MAAoD,CAAA;AAE/F;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,SAAgB,GAAG,QAAQ,KAAG,QAAQ,MAAM,CAaxE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,UAAW,MAAM,KAAG,MAAiE,CAAA;AAEpH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,UAAiB,MAAM,SAAS,MAAM,KAAG,QAAQ,OAAO,CAKjF,CAAA"}

package/dist/types/src/helpers/database.d.ts

@@ -0,0 +1,105 @@
+import { DocumentData, DocumentSnapshot, Firestore, QueryConstraint, QueryDocumentSnapshot, QuerySnapshot } from "firebase/firestore";
+import { FirebaseDocumentInfo } from "../types/index";
+/**
+ * Get participants collection path for database reference.
+ * @notice all participants related documents are store under `ceremonies/<ceremonyId>/participants` collection path.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @returns <string> - the participants collection path.
+ */
+export declare const getParticipantsCollectionPath: (ceremonyId: string) => string;
+/**
+ * Get circuits collection path for database reference.
+ * @notice all circuits related documents are store under `ceremonies/<ceremonyId>/circuits` collection path.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @returns <string> - the participants collection path.
+ */
+export declare const getCircuitsCollectionPath: (ceremonyId: string) => string;
+/**
+ * Get contributions collection path for database reference.
+ * @notice all contributions related documents are store under `ceremonies/<ceremonyId>/circuits/<circuitId>/contributions` collection path.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param circuitId <string> - the unique identifier of the circuit.
+ * @returns <string> - the contributions collection path.
+ */
+export declare const getContributionsCollectionPath: (ceremonyId: string, circuitId: string) => string;
+/**
+ * Get timeouts collection path for database reference.
+ * @notice all timeouts related documents are store under `ceremonies/<ceremonyId>/participants/<participantId>/timeouts` collection path.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param participantId <string> - the unique identifier of the participant.
+ * @returns <string> - the timeouts collection path.
+ */
+export declare const getTimeoutsCollectionPath: (ceremonyId: string, participantId: string) => string;
+/**
+ * Helper for query a collection based on certain constraints.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param collection <string> - the name of the collection.
+ * @param queryConstraints <Array<QueryConstraint>> - a sequence of where conditions.
+ * @returns <Promise<QuerySnapshot<DocumentData>>> - return the matching documents (if any).
+ */
+export declare const queryCollection: (firestoreDatabase: Firestore, collection: string, queryConstraints: Array<QueryConstraint>) => Promise<QuerySnapshot<DocumentData>>;
+/**
+ * Helper for obtaining uid and data for query document snapshots.
+ * @param queryDocSnap <Array<QueryDocumentSnapshot>> - the array of query document snapshot to be converted.
+ * @returns Array<FirebaseDocumentInfo>
+ */
+export declare const fromQueryToFirebaseDocumentInfo: (queryDocSnap: Array<QueryDocumentSnapshot>) => Array<FirebaseDocumentInfo>;
+/**
+ * Fetch for all documents in a collection.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param collection <string> - the name of the collection.
+ * @returns <Promise<Array<QueryDocumentSnapshot<DocumentData>>>> - return all documents (if any).
+ */
+export declare const getAllCollectionDocs: (firestoreDatabase: Firestore, collection: string) => Promise<Array<QueryDocumentSnapshot<DocumentData>>>;
+/**
+ * Get a specific document from database.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param collection <string> - the name of the collection.
+ * @param documentId <string> - the unique identifier of the document in the collection.
+ * @returns <Promise<DocumentSnapshot<DocumentData>>> - return the document from Firestore.
+ */
+export declare const getDocumentById: (firestoreDatabase: Firestore, collection: string, documentId: string) => Promise<DocumentSnapshot<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 getOpenedCeremonies: (firestoreDatabase: Firestore) => Promise<Array<FirebaseDocumentInfo>>;
+/**
+ * Query for ceremony circuits.
+ * @notice the order by sequence position is fundamental to maintain parallelism among contributions for different circuits.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @param ceremonyId <string> - the ceremony unique identifier.
+ * @returns Promise<Array<FirebaseDocumentInfo>> - the ceremony' circuits documents ordered by sequence position.
+ */
+export declare const getCeremonyCircuits: (firestoreDatabase: Firestore, ceremonyId: string) => Promise<Array<FirebaseDocumentInfo>>;
+/**
+ * Query for a specific ceremony' circuit contribution from a given contributor (if any).
+ * @notice if the caller is a coordinator, there could be more than one contribution (= the one from finalization applies to this criteria).
+ * @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 participant.
+ * @returns <Promise<Array<FirebaseDocumentInfo>>> - the document info about the circuit contributions from contributor.
+ */
+export declare const getCircuitContributionsFromContributor: (firestoreDatabase: Firestore, ceremonyId: string, circuitId: string, participantId: string) => Promise<Array<FirebaseDocumentInfo>>;
+/**
+ * Query for the active timeout from given participant for a given ceremony (if any).
+ * @param ceremonyId <string> - the identifier of the ceremony.
+ * @param participantId <string> - the identifier of the participant.
+ * @returns <Promise<Array<FirebaseDocumentInfo>>> - the document info about the current active participant timeout.
+ */
+export declare const getCurrentActiveParticipantTimeout: (firestoreDatabase: Firestore, ceremonyId: string, participantId: string) => Promise<Array<FirebaseDocumentInfo>>;
+/**
+ * Query for the closed ceremonies.
+ * @notice a ceremony is closed when the period for receiving new contributions has ended.
+ * @dev when the ceremony is closed it becomes ready for finalization.
+ * @param firestoreDatabase <Firestore> - the Firestore service instance associated to the current Firebase application.
+ * @returns <Promise<Array<FirebaseDocumentInfo>>> - the list of closed ceremonies.
+ */
+export declare const getClosedCeremonies: (firestoreDatabase: Firestore) => Promise<Array<FirebaseDocumentInfo>>;
+//# sourceMappingURL=database.d.ts.map

package/dist/types/src/helpers/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../../src/helpers/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,YAAY,EACZ,gBAAgB,EAChB,SAAS,EAIT,eAAe,EACf,qBAAqB,EACrB,aAAa,EAGhB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAGrD;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,eAAgB,MAAM,KAAG,MACwC,CAAA;AAE3G;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,eAAgB,MAAM,KAAG,MACwC,CAAA;AAEvG;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,eAAgB,MAAM,aAAa,MAAM,KAAG,MACkB,CAAA;AAEzG;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,eAAgB,MAAM,iBAAiB,MAAM,KAAG,MACsB,CAAA;AAE5G;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,sBACL,SAAS,cAChB,MAAM,oBACA,MAAM,eAAe,CAAC,KACzC,QAAQ,cAAc,YAAY,CAAC,CAQrC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,iBAC1B,MAAM,qBAAqB,CAAC,KAC3C,MAAM,oBAAoB,CAKtB,CAAA;AAEP;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,sBACV,SAAS,cAChB,MAAM,KACnB,QAAQ,MAAM,sBAAsB,YAAY,CAAC,CAAC,CACiB,CAAA;AAEtE;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,sBACL,SAAS,cAChB,MAAM,cACN,MAAM,KACnB,QAAQ,iBAAiB,YAAY,CAAC,CAIxC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,sBAA6B,SAAS,KAAG,QAAQ,MAAM,oBAAoB,CAAC,CAW3G,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,sBACT,SAAS,cAChB,MAAM,KACnB,QAAQ,MAAM,oBAAoB,CAAC,CAG6E,CAAA;AAEnH;;;;;;;;GAQG;AACH,eAAO,MAAM,sCAAsC,sBAC5B,SAAS,cAChB,MAAM,aACP,MAAM,iBACF,MAAM,KACtB,QAAQ,MAAM,oBAAoB,CAAC,CAQrC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC,sBACxB,SAAS,cAChB,MAAM,iBACH,MAAM,KACtB,QAAQ,MAAM,oBAAoB,CAAC,CAQrC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,sBAA6B,SAAS,KAAG,QAAQ,MAAM,oBAAoB,CAAC,CAW3G,CAAA"}

package/dist/types/src/helpers/functions.d.ts

@@ -0,0 +1,145 @@
+import { Functions } from "firebase/functions";
+import { CeremonyInputData, CircuitDocument, ETagWithPartNumber, FirebaseDocumentInfo } from "../types/index";
+/**
+ * Setup a new ceremony by calling the related cloud function.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyInputData <CeremonyInputData> - the input data of the ceremony.
+ * @param ceremonyPrefix <string> - the prefix of the ceremony.
+ * @param circuits <Circuit[]> - the circuits data.
+ * @returns Promise<string> - the unique identifier of the created ceremony.
+ */
+export declare const setupCeremony: (functions: Functions, ceremonyInputData: CeremonyInputData, ceremonyPrefix: string, circuits: CircuitDocument[]) => Promise<string>;
+/**
+ * Check the user's current participant status for the ceremony
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @returns <boolean> - true when participant is able to contribute; otherwise false.
+ */
+export declare const checkParticipantForCeremony: (functions: Functions, ceremonyId: string) => Promise<any>;
+/**
+ * Progress the participant to the next circuit preparing for the next contribution.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ */
+export declare const progressToNextCircuitForContribution: (functions: Functions, ceremonyId: string) => Promise<void>;
+/**
+ * Resume the contributor circuit contribution from scratch after the timeout expiration.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ */
+export declare const resumeContributionAfterTimeoutExpiration: (functions: Functions, ceremonyId: string) => Promise<void>;
+/**
+ * Make a request to create a new AWS S3 bucket for a ceremony.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ */
+export declare const createS3Bucket: (functions: Functions, bucketName: string) => Promise<void>;
+/**
+ * Return a pre-signed url for a given object contained inside the provided AWS S3 bucket in order to perform a GET request.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ * @param objectKey <string> - the storage path that locates the artifact to be downloaded in the bucket.
+ * @returns <Promise<string>> - the pre-signed url w/ GET request permissions for specified object key.
+ */
+export declare const generateGetObjectPreSignedUrl: (functions: Functions, bucketName: string, objectKey: string) => Promise<string>;
+/**
+ * Progress the participant to the next circuit preparing for the next contribution.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ */
+export declare const progressToNextContributionStep: (functions: Functions, ceremonyId: string) => Promise<void>;
+/**
+ * Write the information about current contribution hash and computation time for the current contributor.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param contributionComputationTime <number> - the time when it was computed
+ * @param contributingHash <string> - the hash of the contribution
+ */
+export declare const permanentlyStoreCurrentContributionTimeAndHash: (functions: Functions, ceremonyId: string, contributionComputationTime: number, contributionHash: string) => Promise<void>;
+/**
+ * Start a new multi-part upload for a specific object in the given AWS S3 bucket.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ * @param objectKey <string> - the storage path that locates the artifact to be downloaded in the bucket.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @returns Promise<string> - the multi-part upload id.
+ */
+export declare const openMultiPartUpload: (functions: Functions, bucketName: string, objectKey: string, ceremonyId?: string) => Promise<string>;
+/**
+ * Write temporary information about the unique identifier about the opened multi-part upload to eventually resume the contribution.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param uploadId <string> - the unique identifier of the multi-part upload.
+ */
+export declare const temporaryStoreCurrentContributionMultiPartUploadId: (functions: Functions, ceremonyId: string, uploadId: string) => Promise<void>;
+/**
+ * Write temporary information about the etags and part numbers for each uploaded chunk in order to make the upload resumable from last chunk.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param chunk <ETagWithPartNumber> - the information about the already uploaded chunk.
+ */
+export declare const temporaryStoreCurrentContributionUploadedChunkData: (functions: Functions, ceremonyId: string, chunk: ETagWithPartNumber) => Promise<void>;
+/**
+ * Generate a new pre-signed url for each chunk related to a started multi-part upload.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ * @param objectKey <string> - the storage path that locates the artifact to be downloaded in the bucket.
+ * @param uploadId <string> - the unique identifier of the multi-part upload.
+ * @param numberOfChunks <number> - the number of pre-signed urls to be generated.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @returns Promise<Array<string>> - the set of pre-signed urls (one for each chunk).
+ */
+export declare const generatePreSignedUrlsParts: (functions: Functions, bucketName: string, objectKey: string, uploadId: string, numberOfParts: number, ceremonyId?: string) => Promise<Array<string>>;
+/**
+ * Complete a multi-part upload for a specific object in the given AWS S3 bucket.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ * @param objectKey <string> - the storage path that locates the artifact to be downloaded in the bucket.
+ * @param uploadId <string> - the unique identifier of the multi-part upload.
+ * @param parts Array<ETagWithPartNumber> - the completed .
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @returns Promise<string> - the location of the uploaded ceremony artifact.
+ */
+export declare const completeMultiPartUpload: (functions: Functions, bucketName: string, objectKey: string, uploadId: string, parts: Array<ETagWithPartNumber>, ceremonyId?: string) => Promise<string>;
+/**
+ * Check if a specified object exist in a given AWS S3 bucket.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ * @param objectKey <string> - the storage path that locates the artifact to be downloaded in the bucket.
+ * @returns <Promise<string>> - true if and only if the object exists, otherwise false.
+ */
+export declare const checkIfObjectExist: (functions: Functions, bucketName: string, objectKey: string) => Promise<boolean>;
+/**
+ * Request to verify the newest contribution for the circuit.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param circuit <FirebaseDocumentInfo> - the document info about the circuit.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ * @param contributorOrCoordinatorIdentifier <string> - the identifier of the contributor or coordinator (only when finalizing).
+ * @param verifyContributionCloudFunctionEndpoint <string> - the endpoint (direct url) necessary to call the V2 Cloud Function.
+ * @returns <Promise<void>> -
+ */
+export declare const verifyContribution: (functions: Functions, ceremonyId: string, circuit: FirebaseDocumentInfo, bucketName: string, contributorOrCoordinatorIdentifier: string, verifyContributionCloudFunctionEndpoint: string) => Promise<void>;
+/**
+ * Prepare the coordinator for the finalization of the ceremony.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @returns <Promise<boolean>> - true when the coordinator is ready for finalization; otherwise false.
+ */
+export declare const checkAndPrepareCoordinatorForFinalization: (functions: Functions, ceremonyId: string) => Promise<boolean>;
+/**
+ * Finalize the ceremony circuit.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param circuitId <string> - the unique identifier of the circuit.
+ * @param bucketName <string> - the name of the ceremony bucket.
+ * @param beacon <string> - the value used to compute the final contribution while finalizing the ceremony.
+ */
+export declare const finalizeCircuit: (functions: Functions, ceremonyId: string, circuitId: any, bucketName: string, beacon: string) => Promise<void>;
+/**
+ * Conclude the finalization of the ceremony.
+ * @param functions <Functions> - the Firebase cloud functions object instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ */
+export declare const finalizeCeremony: (functions: Functions, ceremonyId: string) => Promise<void>;
+//# sourceMappingURL=functions.d.ts.map

package/dist/types/src/helpers/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../../../src/helpers/functions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAuC,MAAM,oBAAoB,CAAA;AAEnF,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAG7G;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,cACX,SAAS,qBACD,iBAAiB,kBACpB,MAAM,YACZ,eAAe,EAAE,KAC5B,QAAQ,MAAM,CAShB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,cAAqB,SAAS,cAAc,MAAM,KAAG,QAAQ,GAAG,CAMvG,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oCAAoC,cAAqB,SAAS,cAAc,MAAM,KAAG,QAAQ,IAAI,CAMjH,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,wCAAwC,cACtC,SAAS,cACR,MAAM,KACnB,QAAQ,IAAI,CAMd,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,cAAqB,SAAS,cAAc,MAAM,kBAI5E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,cAC3B,SAAS,cACR,MAAM,aACP,MAAM,KAClB,QAAQ,MAAM,CAShB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,cAAqB,SAAS,cAAc,MAAM,kBAM5F,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,8CAA8C,cAC5C,SAAS,cACR,MAAM,+BACW,MAAM,oBACjB,MAAM,kBAQ3B,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,cACjB,SAAS,cACR,MAAM,aACP,MAAM,eACJ,MAAM,KACpB,QAAQ,MAAM,CAUhB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,kDAAkD,cAChD,SAAS,cACR,MAAM,YACR,MAAM,kBAWnB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,kDAAkD,cAChD,SAAS,cACR,MAAM,SACX,kBAAkB,kBAU5B,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,cACxB,SAAS,cACR,MAAM,aACP,MAAM,YACP,MAAM,iBACD,MAAM,eACR,MAAM,KACpB,QAAQ,MAAM,MAAM,CAAC,CAYvB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,cACrB,SAAS,cACR,MAAM,aACP,MAAM,YACP,MAAM,SACT,MAAM,kBAAkB,CAAC,eACnB,MAAM,KACpB,QAAQ,MAAM,CAahB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,cAChB,SAAS,cACR,MAAM,aACP,MAAM,KAClB,QAAQ,OAAO,CASjB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,cAChB,SAAS,cACR,MAAM,WACT,oBAAoB,cACjB,MAAM,sCACkB,MAAM,2CACD,MAAM,KAChD,QAAQ,IAAI,CAuEd,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC,cACvC,SAAS,cACR,MAAM,KACnB,QAAQ,OAAO,CAQjB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,cACb,SAAS,cACR,MAAM,aACP,GAAG,cACF,MAAM,UACV,MAAM,kBAUjB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,cAAqB,SAAS,cAAc,MAAM,kBAM9E,CAAA"}

package/dist/types/src/helpers/security.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This function will check if the user is reputable enough to be able to use the app
+ * @param userLogin <string> The username of the user
+ * @param minimumAmountOfFollowing <number> The minimum amount of following the user should have
+ * @param minimumAmountOfFollowers <number> The minimum amount of followers the user should have
+ * @param minimumAmountOfPublicRepos <number> The minimum amount of public repos the user should have
+ * @returns <boolean> True if the user is reputable enough, false otherwise
+ */
+export declare const githubReputation: (userLogin: string, minimumAmountOfFollowing: number, minimumAmountOfFollowers: number, minimumAmountOfPublicRepos: number) => Promise<boolean>;
+//# sourceMappingURL=security.d.ts.map

package/dist/types/src/helpers/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../../src/helpers/security.ts"],"names":[],"mappings":"AAwDA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,cACd,MAAM,4BACS,MAAM,4BACN,MAAM,8BACJ,MAAM,KACnC,QAAQ,OAAO,CAgBjB,CAAA"}

package/dist/types/src/helpers/services.d.ts

@@ -0,0 +1,38 @@
+import { FirebaseApp, FirebaseOptions } from "firebase/app";
+import { Firestore } from "firebase/firestore";
+import { Functions } from "firebase/functions";
+import { AWSVariables, FirebaseServices } from "../types/index";
+/**
+ * This method initialize a Firebase app if no other app has already been initialized.
+ * @param options <FirebaseOptions> - an object w/ every necessary Firebase option to init app.
+ * @returns <FirebaseApp> - the initialized Firebase app object.
+ */
+export declare const initializeFirebaseApp: (options: FirebaseOptions) => FirebaseApp;
+/**
+ * This method returns the Firestore database instance associated to the given Firebase application.
+ * @param app <FirebaseApp> - the Firebase application.
+ * @returns <Firestore> - the Firebase Firestore associated to the application.
+ */
+export declare const getFirestoreDatabase: (app: FirebaseApp) => Firestore;
+/**
+ * This method returns the Cloud Functions instance associated to the given Firebase application.
+ * @param app <FirebaseApp> - the Firebase application.
+ * @returns <Functions> - the Cloud Functions associated to the application.
+ */
+export declare const getFirebaseFunctions: (app: FirebaseApp) => Functions;
+/**
+ * Retrieve the configuration variables for the AWS services (S3, EC2).
+ * @returns <AWSVariables> - the values of the AWS services configuration variables.
+ */
+export declare const getAWSVariables: () => AWSVariables;
+/**
+ * Return the core Firebase services instances (App, Database, Functions).
+ * @param apiKey <string> - the API key specified in the application config.
+ * @param authDomain <string> - the authDomain string specified in the application config.
+ * @param projectId <string> - the projectId specified in the application config.
+ * @param messagingSenderId <string> - the messagingSenderId specified in the application config.
+ * @param appId <string> - the appId specified in the application config.
+ * @returns <Promise<FirebaseServices>>
+ */
+export declare const initializeFirebaseCoreServices: (apiKey: string, authDomain: string, projectId: string, messagingSenderId: string, appId: string) => Promise<FirebaseServices>;
+//# sourceMappingURL=services.d.ts.map