@devtion/actions 0.0.0-7e983e3

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

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../../src/helpers/services.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,eAAe,EAAiB,MAAM,cAAc,CAAA;AAC1E,OAAO,EAAE,SAAS,EAAgB,MAAM,oBAAoB,CAAA;AAC5D,OAAO,EAAE,SAAS,EAAgB,MAAM,oBAAoB,CAAA;AAC5D,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAE/D;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,YAAa,eAAe,KAAG,WAAqC,CAAA;AAEtG;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAS,WAAW,KAAG,SAA8B,CAAA;AAEtF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAS,WAAW,KAAG,SAA8C,CAAA;AAEtG;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAO,YAmBlC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,WAC/B,MAAM,cACF,MAAM,aACP,MAAM,qBACE,MAAM,SAClB,MAAM,KACd,QAAQ,gBAAgB,CAgB1B,CAAA"}

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

@@ -0,0 +1,121 @@
+import { Functions } from "firebase/functions";
+import { ETagWithPartNumber, ChunkWithUrl, TemporaryParticipantContributionData } from "../types/index";
+/**
+ * Return the bucket name based on ceremony prefix.
+ * @param ceremonyPrefix <string> - the ceremony prefix.
+ * @param ceremonyPostfix <string> - the ceremony postfix.
+ * @returns <string>
+ */
+export declare const getBucketName: (ceremonyPrefix: string, ceremonyPostfix: string) => string;
+/**
+ * Get chunks and signed urls related to an object that must be uploaded using a multi-part upload.
+ * @param cloudFunctions <Functions> - the Firebase Cloud Functions service instance.
+ * @param bucketName <string> - the name of the ceremony artifacts bucket (AWS S3).
+ * @param objectKey <string> - the unique key to identify the object inside the given AWS S3 bucket.
+ * @param localFilePath <string> - the local path where the artifact will be downloaded.
+ * @param uploadId <string> - the unique identifier of the multi-part upload.
+ * @param configStreamChunkSize <number> - size of each chunk into which the artifact is going to be splitted (nb. will be converted in MB).
+ * @param [ceremonyId] <string> - the unique identifier of the ceremony.
+ * @returns Promise<Array<ChunkWithUrl>> - the chunks with related pre-signed url.
+ */
+export declare const getChunksAndPreSignedUrls: (cloudFunctions: Functions, bucketName: string, objectKey: string, localFilePath: string, uploadId: string, configStreamChunkSize: number, ceremonyId?: string) => Promise<Array<ChunkWithUrl>>;
+/**
+ * Forward the request to upload each single chunk of the related ceremony artifact.
+ * @param chunksWithUrls <Array<ChunkWithUrl>> - the array containing each chunk mapped with the corresponding pre-signed urls.
+ * @param contentType <string | false> - the content type of the ceremony artifact.
+ * @param cloudFunctions <Functions> - the Firebase Cloud Functions service instance.
+ * @param ceremonyId <string> - the unique identifier of the ceremony.
+ * @param alreadyUploadedChunks Array<ETagWithPartNumber> - the temporary information about the already uploaded chunks.
+ * @returns <Promise<Array<ETagWithPartNumber>>> - the completed (uploaded) chunks information.
+ */
+export declare const uploadParts: (chunksWithUrls: Array<ChunkWithUrl>, contentType: string | false, cloudFunctions?: Functions, ceremonyId?: string, alreadyUploadedChunks?: Array<ETagWithPartNumber>) => Promise<Array<ETagWithPartNumber>>;
+/**
+ * Upload a ceremony artifact to the corresponding bucket.
+ * @notice this method implements the multi-part upload using pre-signed urls, optimal for large files.
+ * Steps:
+ * 0) Check if current contributor could resume a multi-part upload.
+ *    0.A) If yes, continue from last uploaded chunk using the already opened multi-part upload.
+ *    0.B) Otherwise, start creating a new multi-part upload.
+ * 1) Generate a pre-signed url for each (remaining) chunk of the ceremony artifact.
+ * 2) Consume the pre-signed urls to upload chunks.
+ * 3) Complete the multi-part upload.
+ * @param cloudFunctions <Functions> - the Firebase Cloud Functions service instance.
+ * @param bucketName <string> - the name of the ceremony artifacts bucket (AWS S3).
+ * @param objectKey <string> - the unique key to identify the object inside the given AWS S3 bucket.
+ * @param localPath <string> - the local path where the artifact will be downloaded.
+ * @param configStreamChunkSize <number> - size of each chunk into which the artifact is going to be splitted (nb. will be converted in MB).
+ * @param [ceremonyId] <string> - the unique identifier of the ceremony (used as a double-edge sword - as identifier and as a check if current contributor is the coordinator finalizing the ceremony).
+ * @param [temporaryDataToResumeMultiPartUpload] <TemporaryParticipantContributionData> - the temporary information necessary to resume an already started multi-part upload.
+ */
+export declare const multiPartUpload: (cloudFunctions: Functions, bucketName: string, objectKey: string, localFilePath: string, configStreamChunkSize: number, ceremonyId?: string, temporaryDataToResumeMultiPartUpload?: TemporaryParticipantContributionData) => Promise<void>;
+/**
+ * Download an artifact from S3 (only for authorized users)
+ * @param cloudFunctions <Functions> Firebase cloud functions instance.
+ * @param bucketName <string> Name of the bucket where the artifact is stored.
+ * @param storagePath <string> Path to the artifact in the bucket.
+ * @param localPath <string> Path to the local file where the artifact will be saved.
+ */
+export declare const downloadCeremonyArtifact: (cloudFunctions: Functions, bucketName: string, storagePath: string, localPath: string) => Promise<void>;
+/**
+ * Get R1CS file path tied to a particular circuit of a ceremony in the storage.
+ * @notice each R1CS file in the storage must be stored in the following path: `circuits/<circuitPrefix>/<completeR1csFilename>`.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param circuitPrefix <string> - the prefix of the circuit.
+ * @param completeR1csFilename <string> - the complete R1CS filename (name + ext).
+ * @returns <string> - the storage path of the R1CS file.
+ */
+export declare const getR1csStorageFilePath: (circuitPrefix: string, completeR1csFilename: string) => string;
+/**
+ * Get WASM file path tied to a particular circuit of a ceremony in the storage.
+ * @notice each WASM file in the storage must be stored in the following path: `circuits/<circuitPrefix>/<completeWasmFilename>`.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param circuitPrefix <string> - the prefix of the circuit.
+ * @param completeWasmFilename <string> - the complete WASM filename (name + ext).
+ * @returns <string> - the storage path of the WASM file.
+ */
+export declare const getWasmStorageFilePath: (circuitPrefix: string, completeWasmFilename: string) => string;
+/**
+ * Get PoT file path in the storage.
+ * @notice each PoT file in the storage must be stored in the following path: `pot/<completePotFilename>`.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param completePotFilename <string> - the complete PoT filename (name + ext).
+ * @returns <string> - the storage path of the PoT file.
+ */
+export declare const getPotStorageFilePath: (completePotFilename: string) => string;
+/**
+ * Get zKey file path tied to a particular circuit of a ceremony in the storage.
+ * @notice each zKey file in the storage must be stored in the following path: `circuits/<circuitPrefix>/contributions/<completeZkeyFilename>`.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param circuitPrefix <string> - the prefix of the circuit.
+ * @param completeZkeyFilename <string> - the complete zKey filename (name + ext).
+ * @returns <string> - the storage path of the zKey file.
+ */
+export declare const getZkeyStorageFilePath: (circuitPrefix: string, completeZkeyFilename: string) => string;
+/**
+ * Get verification key file path tied to a particular circuit of a ceremony in the storage.
+ * @notice each verification key file in the storage must be stored in the following path: `circuits/<circuitPrefix>/<completeVerificationKeyFilename>`.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param circuitPrefix <string> - the prefix of the circuit.
+ * @param completeVerificationKeyFilename <string> - the complete verification key filename (name + ext).
+ * @returns <string> - the storage path of the verification key file.
+ */
+export declare const getVerificationKeyStorageFilePath: (circuitPrefix: string, completeVerificationKeyFilename: string) => string;
+/**
+ * Get verifier contract file path tied to a particular circuit of a ceremony in the storage.
+ * @notice each verifier contract file in the storage must be stored in the following path: `circuits/<circuitPrefix>/<completeVerificationKeyFilename>`.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param circuitPrefix <string> - the prefix of the circuit.
+ * @param completeVerifierContractFilename <string> - the complete verifier contract filename (name + ext).
+ * @returns <string> - the storage path of the verifier contract file.
+ */
+export declare const getVerifierContractStorageFilePath: (circuitPrefix: string, completeVerifierContractFilename: string) => string;
+/**
+ * Get transcript file path tied to a particular circuit of a ceremony in the storage.
+ * @notice each R1CS file in the storage must be stored in the following path: `circuits/<circuitPrefix>/<completeTranscriptFilename>`.
+ * nb. This is a rule that must be satisfied. This is NOT an optional convention.
+ * @param circuitPrefix <string> - the prefix of the circuit.
+ * @param completeTranscriptFilename <string> - the complete transcript filename (name + ext).
+ * @returns <string> - the storage path of the transcript file.
+ */
+export declare const getTranscriptStorageFilePath: (circuitPrefix: string, completeTranscriptFilename: string) => string;
+//# sourceMappingURL=storage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../src/helpers/storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAK9C,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,oCAAoC,EAAE,MAAM,gBAAgB,CAAA;AAWvG;;;;;GAKG;AACH,eAAO,MAAM,aAAa,mBAAoB,MAAM,mBAAmB,MAAM,KAAG,MACvC,CAAA;AAEzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,mBAClB,SAAS,cACb,MAAM,aACP,MAAM,iBACF,MAAM,YACX,MAAM,yBACO,MAAM,eAChB,MAAM,KACpB,QAAQ,MAAM,YAAY,CAAC,CA6B7B,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,mBACJ,MAAM,YAAY,CAAC,eACtB,MAAM,GAAG,KAAK,mBACV,SAAS,eACb,MAAM,0BACK,MAAM,kBAAkB,CAAC,KAClD,QAAQ,MAAM,kBAAkB,CAAC,CA2CnC,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,mBACR,SAAS,cACb,MAAM,aACP,MAAM,iBACF,MAAM,yBACE,MAAM,eAChB,MAAM,yCACoB,oCAAoC,kBAoD9E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,mBACjB,SAAS,cACb,MAAM,eACL,MAAM,aACR,MAAM,kBAuBpB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,kBAAmB,MAAM,wBAAwB,MAAM,KAAG,MACN,CAAA;AAEvF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,kBAAmB,MAAM,wBAAwB,MAAM,KAAG,MACN,CAAA;AAEvF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,wBAAyB,MAAM,KAAG,MACA,CAAA;AAEpE;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,kBAAmB,MAAM,wBAAwB,MAAM,KAAG,MACwC,CAAA;AAErI;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC,kBAC3B,MAAM,mCACY,MAAM,KACxC,MAAwG,CAAA;AAE3G;;;;;;;GAOG;AACH,eAAO,MAAM,kCAAkC,kBAC5B,MAAM,oCACa,MAAM,KACzC,MAAyG,CAAA;AAE5G;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,kBAAmB,MAAM,8BAA8B,MAAM,KAAG,MACoC,CAAA"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../../../src/helpers/tasks.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,139 @@
+/// <reference types="node" />
+import { Firestore } from "firebase/firestore";
+import { ReadPosition } from "fs";
+import winston, { Logger } from "winston";
+import { CircuitMetadata, Contribution, ContributionValidity, FirebaseDocumentInfo, SetupCeremonyData } from "../types/index";
+/**
+ * Parse and validate that the ceremony configuration is correct
+ * @notice this does not upload any files to storage
+ * @param path <string> - the path to the configuration file
+ * @param cleanup <boolean> - whether to delete the r1cs file after parsing
+ * @returns any - the data to pass to the cloud function for setup and the circuit artifacts
+ */
+export declare const parseCeremonyFile: (path: string, cleanup?: boolean) => Promise<SetupCeremonyData>;
+/**
+ * Extract data from a R1CS metadata file generated with a custom file-based logger.
+ * @notice useful for extracting metadata circuits contained in the generated file using a logger
+ * on the `r1cs.info()` method of snarkjs.
+ * @param fullFilePath <string> - the full path of the file.
+ * @param keyRgx <RegExp> - the regular expression linked to the key from which you want to extract the value.
+ * @returns <string> - the stringified extracted value.
+ */
+export declare const extractR1CSInfoValueForGivenKey: (fullFilePath: string, keyRgx: RegExp) => string;
+/**
+ * Calculate the smallest amount of Powers of Tau needed for a circuit with a constraint size.
+ * @param constraints <number> - the number of circuit constraints (extracted from metadata).
+ * @param outputs <number> - the number of circuit outputs (extracted from metadata)
+ * @returns <number> - the smallest amount of Powers of Tau for the given constraint size.
+ */
+export declare const computeSmallestPowersOfTauForCircuit: (constraints: number, outputs: number) => number;
+/**
+ * Transform a number in a zKey index format.
+ * @dev this method is aligned with the number of characters of the genesis zKey index (which is a constant).
+ * @param progress <number> - the progression in zKey index.
+ * @returns <string> - the progression in a zKey index format (`XYZAB`).
+ */
+export declare const formatZkeyIndex: (progress: number) => string;
+/**
+ * Extract the amount of powers from Powers of Tau file name.
+ * @dev the PoT files must follow these convention (i_am_a_pot_file_09.ptau) where the numbers before '.ptau' are the powers.
+ * @param potCompleteFilename <string> - the complete filename of the Powers of Tau file.
+ * @returns <number> - the amount of powers.
+ */
+export declare const extractPoTFromFilename: (potCompleteFilename: string) => number;
+/**
+ * Extract a prefix consisting of alphanumeric and underscore characters from a string with arbitrary characters.
+ * @dev replaces all special symbols and whitespaces with an underscore char ('_'). Convert all uppercase chars to lowercase.
+ * @notice example: str = 'Multiplier-2!2.4.zkey'; output prefix = 'multiplier_2_2_4.zkey'.
+ * NB. Prefix extraction is a key process that conditions the name of the ceremony artifacts, download/upload from/to storage, collections paths.
+ * @param str <string> - the arbitrary string from which to extract the prefix.
+ * @returns <string> - the resulting prefix.
+ */
+export declare const extractPrefix: (str: string) => string;
+/**
+ * Automate the generation of an entropy for a contribution.
+ * @dev Took inspiration from here https://github.com/glamperd/setup-mpc-ui/blob/master/client/src/state/Compute.tsx#L112.
+ * @todo we need to improve the entropy generation (too naive).
+ * @returns <string> - the auto-generated entropy.
+ */
+export declare const autoGenerateEntropy: () => string;
+/**
+ * Check and return the circuit document based on its sequence position among a set of circuits (if any).
+ * @dev there should be only one circuit with a provided sequence position. This method checks and return an
+ * error if none is found.
+ * @param circuits <Array<FirebaseDocumentInfo>> - the set of ceremony circuits documents.
+ * @param sequencePosition <number> - the sequence position (index) of the circuit to be found and returned.
+ * @returns <FirebaseDocumentInfo> - the document of the circuit in the set of circuits that has the provided sequence position.
+ */
+export declare const getCircuitBySequencePosition: (circuits: Array<FirebaseDocumentInfo>, sequencePosition: number) => FirebaseDocumentInfo;
+/**
+ * Convert bytes or chilobytes into gigabytes with customizable precision.
+ * @param bytesOrKb <number> - the amount of bytes or chilobytes to be converted.
+ * @param isBytes <boolean> - true when the amount to be converted is in bytes; otherwise false (= Chilobytes).
+ * @returns <number> - the converted amount in GBs.
+ */
+export declare const convertBytesOrKbToGb: (bytesOrKb: number, isBytes: boolean) => number;
+/**
+ * Get the validity of contributors' contributions for each circuit of the given ceremony (if any).
+ * @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 isFinalizing <boolean> - flag to discriminate between ceremony finalization (true) and contribution (false).
+ * @returns <Promise<Array<ContributionValidity>>> - a list of contributor contributions together with contribution validity (based on coordinator verification).
+ */
+export declare const getContributionsValidityForContributor: (firestoreDatabase: Firestore, circuits: Array<FirebaseDocumentInfo>, ceremonyId: string, participantId: string, isFinalizing: boolean) => Promise<Array<ContributionValidity>>;
+/**
+ * Return the public attestation preamble for given contributor.
+ * @param contributorIdentifier <string> - the identifier of the contributor (handle, name, uid).
+ * @param ceremonyName <string> - the name of the ceremony.
+ * @param isFinalizing <boolean> - true when the coordinator is finalizing the ceremony, otherwise false.
+ * @returns <string> - the public attestation preamble.
+ */
+export declare const getPublicAttestationPreambleForContributor: (contributorIdentifier: string, ceremonyName: string, isFinalizing: boolean) => string;
+/**
+ * Check and prepare public attestation for the contributor made only of its valid contributions.
+ * @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 isFinalizing <boolean> - true when the coordinator is finalizing the ceremony, otherwise false.
+ * @returns <Promise<string>> - the public attestation for the contributor.
+ */
+export declare const generateValidContributionsAttestation: (firestoreDatabase: Firestore, circuits: Array<FirebaseDocumentInfo>, ceremonyId: string, participantId: string, participantContributions: Array<Contribution>, contributorIdentifier: string, ceremonyName: string, isFinalizing: boolean) => Promise<string>;
+/**
+ * Create a custom logger to write logs on a local file.
+ * @param filename <string> - the name of the output file (where the logs are going to be written).
+ * @param level <winston.LoggerOptions["level"]> - the option for the logger level (e.g., info, error).
+ * @returns <Logger> - a customized winston logger for files.
+ */
+export declare const createCustomLoggerForFile: (filename: string, level?: winston.LoggerOptions["level"]) => Logger;
+/**
+ * Return an amount of bytes read from a file to a particular location in the form of a buffer.
+ * @param localFilePath <string> - the local path where the artifact will be downloaded.
+ * @param offset <number> - the index of the line to be read (0 from the start).
+ * @param length <number> - the length of the line to be read.
+ * @param position <ReadPosition> - the position inside the file.
+ * @returns <Buffer> - the buffer w/ the read bytes.
+ */
+export declare const readBytesFromFile: (localFilePath: string, offset: number, length: number, position: ReadPosition) => Buffer;
+/**
+ * Return the info about the R1CS file.ù
+ * @dev this method was built taking inspiration from
+ * https://github.com/weijiekoh/circom-helper/blob/master/ts/read_num_inputs.ts#L5.
+ * You can find the specs of R1CS file here
+ * https://github.com/iden3/r1csfile/blob/master/doc/r1cs_bin_format.md
+ * @param localR1CSFilePath <string> - the local path to the R1CS file.
+ * @returns <CircuitMetadata> - the info about the R1CS file.
+ */
+export declare const getR1CSInfo: (localR1CSFilePath: string) => CircuitMetadata;
+/**
+ * Return a string with double digits if the provided input is one digit only.
+ * @param in <number> - the input number to be converted.
+ * @returns <string> - the two digits stringified number derived from the conversion.
+ */
+export declare const convertToDoubleDigits: (amount: number) => string;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/helpers/utils.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAW,EAAE,YAAY,EAAE,MAAM,IAAI,CAAA;AAErC,OAAO,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAEzC,OAAO,EACH,eAAe,EACf,YAAY,EAGZ,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EAGpB,MAAM,gBAAgB,CAAA;AAmBvB;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,SAAgB,MAAM,YAAW,OAAO,KAAW,QAAQ,iBAAiB,CAoOzG,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,iBAAkB,MAAM,UAAU,MAAM,KAAG,MAgBtF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,gBAAiB,MAAM,WAAW,MAAM,WAUxF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,aAAc,MAAM,KAAG,MASlD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,wBAAyB,MAAM,KAAG,MACH,CAAA;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,QAAS,MAAM,KAAG,MAEsC,CAAA;AAElF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,cAAsE,CAAA;AAEtG;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,aAC3B,MAAM,oBAAoB,CAAC,oBACnB,MAAM,KACzB,oBAYF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,cAAe,MAAM,WAAW,OAAO,KAAG,MAC1B,CAAA;AAEjD;;;;;;;;GAQG;AACH,eAAO,MAAM,sCAAsC,sBAC5B,SAAS,YAClB,MAAM,oBAAoB,CAAC,cACzB,MAAM,iBACH,MAAM,gBACP,OAAO,KACtB,QAAQ,MAAM,oBAAoB,CAAC,CAmCrC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0CAA0C,0BAC5B,MAAM,gBACf,MAAM,gBACN,OAAO,WAImF,CAAA;AAE5G;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qCAAqC,sBAC3B,SAAS,YAClB,MAAM,oBAAoB,CAAC,cACzB,MAAM,iBACH,MAAM,4BACK,MAAM,YAAY,CAAC,yBACtB,MAAM,gBACf,MAAM,gBACN,OAAO,KACtB,QAAQ,MAAM,CA2DhB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,aAAc,MAAM,UAAS,QAAQ,aAAa,CAAC,OAAO,CAAC,KAAY,MAQvG,CAAA;AAEN;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,kBACX,MAAM,UACb,MAAM,UACN,MAAM,YACJ,YAAY,KACvB,MAYF,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,sBAAuB,MAAM,KAAG,eA0IvD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,WAAY,MAAM,KAAG,MAA0D,CAAA"}

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

@@ -0,0 +1,95 @@
+import { Firestore } from "firebase/firestore";
+import { Functions } from "firebase/functions";
+import { CeremonyArtifacts } from "../types/index";
+/**
+ * Verify that a zKey is valid
+ * @param r1csLocalFilePath <string> path to the r1cs file
+ * @param zkeyLocalPath <string> path to the zKey file
+ * @param potLocalFilePath <string> path to the PoT file
+ * @param logger <any> logger instance
+ * @returns <boolean> true if the zKey is valid, false otherwise
+ */
+export declare const verifyZKey: (r1csLocalFilePath: string, zkeyLocalPath: string, potLocalFilePath: string, logger?: any) => Promise<boolean>;
+/**
+ * Generates a GROTH16 proof
+ * @param circuitInput <object> Input to the circuit
+ * @param zkeyFilePath <string> Path to the proving key
+ * @param wasmFilePath <string> Path to the compiled circuit
+ * @param logger <any> Optional logger
+ * @returns <Promise<object>> The proof
+ */
+export declare const generateGROTH16Proof: (circuitInput: object, zkeyFilePath: string, wasmFilePath: string, logger?: any) => Promise<any>;
+/**
+ * Verifies a GROTH16 proof
+ * @param verificationKeyPath <string> Path to the verification key
+ * @param publicSignals <object> Public signals
+ * @param proof <object> Proof
+ * @returns <Promise<boolean>> Whether the proof is valid or not
+ */
+export declare const verifyGROTH16Proof: (verificationKeyPath: string, publicSignals: object, proof: object) => Promise<boolean>;
+/**
+ * Helper method to extract the Solidity verifier
+ * from a final zKey file and save it to a local file.
+ * @param finalZkeyPath <string> The path to the zKey file.
+ * @return <any> The Solidity verifier code.
+ */
+export declare const exportVerifierContract: (finalZkeyPath: string, templatePath: string) => Promise<any>;
+/**
+ * Helpers method to extract the vKey from a final zKey file
+ * @param finalZkeyPath <string> The path to the zKey file.
+ * @return <any> The vKey.
+ */
+export declare const exportVkey: (finalZkeyPath: string) => Promise<any>;
+/**
+ * Helper method to extract the Solidity verifier and the Verification key
+ * from a final zKey file and save them to local files.
+ * @param finalZkeyPath <string> The path to the zKey file.
+ * @param verifierLocalPath <string> The path to the local file where the verifier will be saved.
+ * @param vKeyLocalPath <string> The path to the local file where the vKey will be saved.
+ * @param templatePath <string> The path to the template file.
+ */
+export declare const exportVerifierAndVKey: (finalZkeyPath: string, verifierLocalPath: string, vKeyLocalPath: string, templatePath: string) => Promise<void>;
+/**
+ * Generate a zKey from scratch (useful to compute either the genesis or final zKey)
+ * @param isFinalizing <boolean> Whether the ceremony is finalizing or not
+ * @param r1csLocalPath <string> The path to the local r1cs file
+ * @param potLocalPath <string> The path to the local pot file
+ * @param zkeyLocalPath <string> The path to save the generated zKey
+ * @param logger <any> The logger instance
+ * @param finalContributionZKeyLocalPath <string> The path to the local zkey file of the final contribution (only for final zKey)
+ * @param coordinatorIdentifier <string> The identifier of the coordinator (only for final zKey)
+ * @param beacon <string> The beacon value for the last contribution (only for final zKey)
+ */
+export declare const generateZkeyFromScratch: (isFinalizing: boolean, r1csLocalPath: string, potLocalPath: string, zkeyLocalPath: string, logger: any, finalContributionZKeyLocalPath?: string, coordinatorIdentifier?: string, beacon?: string) => Promise<void>;
+/**
+ * Helper function used to compare two ceremony artifacts
+ * @param firebaseFunctions <Functions> Firebase functions object
+ * @param localPath1 <string> Local path to store the first artifact
+ * @param localPath2 <string> Local path to store the second artifact
+ * @param storagePath1 <string> Storage path to the first artifact
+ * @param storagePath2 <string> Storage path to the second artifact
+ * @param bucketName1 <string> Bucket name of the first artifact
+ * @param bucketName2 <string> Bucket name of the second artifact
+ * @param cleanup <boolean> Whether to delete the downloaded files or not
+ * @returns <Promise<boolean>> true if the hashes match, false otherwise
+ */
+export declare const compareCeremonyArtifacts: (firebaseFunctions: Functions, localPath1: string, localPath2: string, storagePath1: string, storagePath2: string, bucketName1: string, bucketName2: string, cleanup: boolean) => Promise<boolean>;
+/**
+ * Given a ceremony prefix, download all the ceremony artifacts
+ * @param functions <Functions> firebase functions instance
+ * @param firestore <Firestore> firebase firestore instance
+ * @param ceremonyPrefix <string> ceremony prefix
+ * @param outputDirectory <string> output directory where to
+ * @returns <Promise<CeremonyArtifacts[]>> array of ceremony artifacts
+ */
+export declare const downloadAllCeremonyArtifacts: (functions: Functions, firestore: Firestore, ceremonyPrefix: string, outputDirectory: string) => Promise<CeremonyArtifacts[]>;
+/**
+ * Fetch the final contribution beacon from Firestore
+ * @param firestore <Firestore> firebase firestore instance
+ * @param ceremonyId <string> ceremony id
+ * @param circuitId <string> circuit id
+ * @param participantId <string> participant id
+ * @returns <Promise<string>> final contribution beacon
+ */
+export declare const getFinalContributionBeacon: (firestore: Firestore, ceremonyId: string, circuitId: string, participantId: string) => Promise<string>;
+//# sourceMappingURL=verification.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verification.d.ts","sourceRoot":"","sources":["../../../../src/helpers/verification.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAS,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAyB9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAElD;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,sBACA,MAAM,iBACV,MAAM,oBACH,MAAM,WACf,GAAG,KACb,QAAQ,OAAO,CASjB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,iBACf,MAAM,gBACN,MAAM,gBACN,MAAM,WACX,GAAG,KACb,QAAQ,GAAG,CAYb,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,wBACN,MAAM,iBACZ,MAAM,SACd,MAAM,KACd,QAAQ,OAAO,CAIjB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,kBAAyB,MAAM,gBAAgB,MAAM,iBAcvF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,kBAAyB,MAAM,iBAGrD,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,kBACf,MAAM,qBACF,MAAM,iBACV,MAAM,gBACP,MAAM,kBAMvB,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,iBAClB,OAAO,iBACN,MAAM,gBACP,MAAM,iBACL,MAAM,UACb,GAAG,mCACsB,MAAM,0BACf,MAAM,WACrB,MAAM,kBAqBlB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,sBACd,SAAS,cAChB,MAAM,cACN,MAAM,gBACJ,MAAM,gBACN,MAAM,eACP,MAAM,eACN,MAAM,WACV,OAAO,KACjB,QAAQ,OAAO,CAajB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,cAC1B,SAAS,aACT,SAAS,kBACJ,MAAM,mBACL,MAAM,KACxB,QAAQ,iBAAiB,EAAE,CAqF7B,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,cACxB,SAAS,cACR,MAAM,aACP,MAAM,iBACF,MAAM,KACtB,QAAQ,MAAM,CAYhB,CAAA"}

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

@@ -0,0 +1,112 @@
+import { EC2Client } from "@aws-sdk/client-ec2";
+import { SSMClient } from "@aws-sdk/client-ssm";
+import { DiskTypeForVM } from "src";
+import { EC2Instance } from "../types";
+/**
+ * Create a new AWS EC2 client.
+ * @returns <Promise<EC2Client>> - the EC2 client instance.
+ */
+export declare const createEC2Client: () => Promise<EC2Client>;
+/**
+ * Create a new AWS SSM client.
+ * @returns <Promise<SSMClient>> - the SSM client instance.
+ */
+export declare const createSSMClient: () => Promise<SSMClient>;
+/**
+ * Return the list of bootstrap commands to be executed.
+ * @dev the startup commands must be suitable for a shell script.
+ * @param bucketName <string> - the name of the AWS S3 bucket.
+ * @returns <Array<string>> - the list of startup commands to be executed.
+ */
+export declare const vmBootstrapCommand: (bucketName: string) => Array<string>;
+/**
+ * Return the list of Node environment (and packages) installation plus artifact caching for contribution verification.
+ * @param zKeyPath <string> - the path to zKey artifact inside AWS S3 bucket.
+ * @param potPath <string> - the path to ptau artifact inside AWS S3 bucket.
+ * @param snsTopic <string> - the SNS topic ARN.
+ * @param region <string> - the AWS region.
+ * @returns <Array<string>> - the array of commands to be run by the EC2 instance.
+ */
+export declare const vmDependenciesAndCacheArtifactsCommand: (zKeyPath: string, potPath: string, snsTopic: string, region: string) => Array<string>;
+/**
+ * Return the list of commands for contribution verification.
+ * @dev this method generates the verification transcript as well.
+ * @param bucketName <string> - the name of the AWS S3 bucket.
+ * @param lastZkeyStoragePath <string> - the last zKey storage path.
+ * @param verificationTranscriptStoragePathAndFilename <string> - the verification transcript storage path.
+ * @returns Array<string> - the list of commands for contribution verification.
+ */
+export declare const vmContributionVerificationCommand: (bucketName: string, lastZkeyStoragePath: string, verificationTranscriptStoragePathAndFilename: string) => Array<string>;
+/**
+ * Compute the VM disk size.
+ * @dev the disk size is computed using the zKey size in bytes taking into consideration
+ * the verification task (2 * zKeySize) + ptauSize + OS/VM (~8GB).
+ * @param zKeySizeInBytes <number> the size of the zKey in bytes.
+ * @param pot <number> the amount of powers needed for the circuit (index of the PPoT file).
+ * @return <number> the configuration of the VM disk size in GB.
+ */
+export declare const computeDiskSizeForVM: (zKeySizeInBytes: number, pot: number) => number;
+/**
+ * Creates a new EC2 instance
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param commands <Array<string>> - the list of commands to be run on the EC2 instance.
+ * @param instanceType <string> - the type of the EC2 VM instance.
+ * @param diskSize <number> - the size of the disk (volume) of the VM.
+ * @param diskType <DiskTypeForVM> - the type of the disk (volume) of the VM.
+ * @returns <Promise<P0tionEC2Instance>> the instance that was created
+ */
+export declare const createEC2Instance: (ec2: EC2Client, commands: string[], instanceType: string, volumeSize: number, diskType: DiskTypeForVM) => Promise<EC2Instance>;
+/**
+ * Check if the current VM EC2 instance is running by querying the status.
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ * @returns <Promise<boolean>> - true if the current status of the EC2 VM instance is 'running'; otherwise false.
+ */
+export declare const checkIfRunning: (ec2Client: EC2Client, instanceId: string) => Promise<boolean>;
+/**
+ * Start an EC2 VM instance.
+ * @dev the instance must have been created previously.
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ */
+export declare const startEC2Instance: (ec2: EC2Client, instanceId: string) => Promise<void>;
+/**
+ * Stop an EC2 VM instance.
+ * @dev the instance must have been in a running status.
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ */
+export declare const stopEC2Instance: (ec2: EC2Client, instanceId: string) => Promise<void>;
+/**
+ * Terminate an EC2 VM instance.
+ * @param ec2 <EC2Client> - the instance of the EC2 client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ */
+export declare const terminateEC2Instance: (ec2: EC2Client, instanceId: string) => Promise<void>;
+/**
+ * Run a command on an EC2 VM instance by using SSM.
+ * @dev this method returns the command identifier for checking the status and retrieve
+ * the output of the command execution later on.
+ * @param ssm <SSMClient> - the instance of the sSM client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ * @param commands <Array<string>> - the list of commands.
+ * @return <Promise<string>> - the unique identifier of the command.
+ */
+export declare const runCommandUsingSSM: (ssm: SSMClient, instanceId: string, commands: Array<string>) => Promise<string>;
+/**
+ * Get the output of an SSM command executed on an EC2 VM instance.
+ * @param ssm <SSMClient> - the instance of the sSM client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ * @param commandId <string> - the unique identifier of the command.
+ * @return <Promise<string>> - the command output.
+ */
+export declare const retrieveCommandOutput: (ssm: SSMClient, instanceId: string, commandId: string) => Promise<string>;
+/**
+ * Get the status of an SSM command executed on an EC2 VM instance.
+ * @param ssm <SSMClient> - the instance of the sSM client.
+ * @param instanceId <string> - the unique identifier of the EC2 VM instance.
+ * @param commandId <string> - the unique identifier of the command.
+ * @return <Promise<string>> - the command status.
+ */
+export declare const retrieveCommandStatus: (ssm: SSMClient, instanceId: string, commandId: string) => Promise<string>;
+//# sourceMappingURL=vm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vm.d.ts","sourceRoot":"","sources":["../../../../src/helpers/vm.ts"],"names":[],"mappings":"AAAA,OAAO,EAMH,SAAS,EAEZ,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAEH,SAAS,EAGZ,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAOtC;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAa,QAAQ,SAAS,CAYzD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAa,QAAQ,SAAS,CAYzD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,eAAgB,MAAM,KAAG,MAAM,MAAM,CAInE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sCAAsC,aACrC,MAAM,WACP,MAAM,YACL,MAAM,UACR,MAAM,KACf,MAAM,MAAM,CAoBd,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC,eAC9B,MAAM,uBACG,MAAM,gDACmB,MAAM,KACrD,MAAM,MAAM,CAMd,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,oBAAqB,MAAM,OAAO,MAAM,KAAG,MACuB,CAAA;AAEnG;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,QACrB,SAAS,YACJ,MAAM,EAAE,gBACJ,MAAM,cACR,MAAM,YACR,aAAa,KACxB,QAAQ,WAAW,CAgErB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,cAAqB,SAAS,cAAc,MAAM,KAAG,QAAQ,OAAO,CAe9F,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QAAe,SAAS,cAAc,MAAM,kBAYxE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,QAAe,SAAS,cAAc,MAAM,kBAYvE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAe,SAAS,cAAc,MAAM,kBAc5E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,QACtB,SAAS,cACF,MAAM,YACR,MAAM,MAAM,CAAC,KACxB,QAAQ,MAAM,CAwBhB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,QAAe,SAAS,cAAc,MAAM,aAAa,MAAM,KAAG,QAAQ,MAAM,CAiBjH,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,QAAe,SAAS,cAAc,MAAM,aAAa,MAAM,KAAG,QAAQ,MAAM,CAgBjH,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"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"}