fix(vms): tests

ctrlc03 · ctrlc03 · commit dfbf3a7422e7 · 2023-06-22T17:35:47.000+01:00
diff --git a/packages/actions/test/unit/ec2.test.ts b/packages/actions/test/unit/ec2.test.ts
@@ -1,7 +1,8 @@
 import chai, { expect } from "chai"
 import chaiAsPromised from "chai-as-promised"
 import { EC2Client } from "@aws-sdk/client-ec2"
-import { createMockUser, generateUserPasswords, getStorageConfiguration, initializeAdminServices, initializeUserServices, sleep } from "../utils"
+import fetch from "@adobe/node-fetch-retry"
+import { createMockUser, envType, generateUserPasswords, getStorageConfiguration, getTranscriptLocalFilePath, initializeAdminServices, initializeUserServices, sleep } from "../utils"
 import {  
     checkEC2Status, 
     createEC2Client, 
@@ -17,9 +18,13 @@ import {
 } from "../../src/helpers/ec2"
 import { P0tionEC2Instance } from "../../src/types"
 import { fakeCeremoniesData, fakeCircuitsData, fakeUsersData } from "../data/samples"
-import { getAuth, signInWithEmailAndPassword } from "firebase/auth"
+import { getAuth, signInWithEmailAndPassword, signOut } from "firebase/auth"
 import { SSMClient } from "@aws-sdk/client-ssm"
-import { commonTerms, createS3Bucket, getBucketName, getCeremonyCircuits, getDocumentById, setupCeremony } from "../../src"
+import { TestingEnvironment, checkParticipantForCeremony, commonTerms, createCustomLoggerForFile, createS3Bucket, formatZkeyIndex, generateGetObjectPreSignedUrl, genesisZkeyIndex, getBucketName, getCeremonyCircuits, getCircuitBySequencePosition, getCircuitsCollectionPath, getDocumentById, getParticipantsCollectionPath, getPotStorageFilePath, getZkeyStorageFilePath, multiPartUpload, permanentlyStoreCurrentContributionTimeAndHash, progressToNextCircuitForContribution, progressToNextContributionStep, setupCeremony, verifyContribution } from "../../src"
+import { cwd } from "process"
+import fs from "fs"
+import { zKey } from "snarkjs"
+import { randomBytes } from "crypto"
 chai.use(chaiAsPromised)
 
 // @note AWS EC2 on demand VM tests
@@ -34,82 +39,82 @@ describe("VMs", () => {
         ec2 = await createEC2Client()
     })
 
-    // describe("EC2", () => {
-    //     it("should create an instance", async () => {
-    //         instance = await createEC2Instance(ec2, [], "t2.micro", amiId, keyName, roleArn)
-    //         expect(instance).to.not.be.undefined
-    //         // give it time to actually spin up 
-    //         await sleep(250000)
-    //     })
+    describe("EC2", () => {
+        it("should create an instance", async () => {
+            instance = await createEC2Instance(ec2, [], "t2.micro", amiId, keyName, roleArn)
+            expect(instance).to.not.be.undefined
+            // give it time to actually spin up 
+            await sleep(250000)
+        })
     
-    //     it("checkEC2Status should return true for an instance that is running", async () => {
-    //         const response = await checkEC2Status(ec2, instance.InstanceId!)
-    //         expect(response).to.be.true 
-    //     })  
+        it("checkEC2Status should return true for an instance that is running", async () => {
+            const response = await checkEC2Status(ec2, instance.InstanceId!)
+            expect(response).to.be.true 
+        })  
     
-    //     it("getEC2Ip should return an ip", async () => {
-    //         const ip = await getEC2Ip(ec2, instance.InstanceId!)
-    //         expect(ip).to.not.be.undefined
-    //         previousIp = ip!
-    //     })
+        it("getEC2Ip should return an ip", async () => {
+            const ip = await getEC2Ip(ec2, instance.InstanceId!)
+            expect(ip).to.not.be.undefined
+            previousIp = ip!
+        })
     
-    //     it("stopEC2Instance should stop an instance", async () => {
-    //         await expect(stopEC2Instance(ec2, instance.InstanceId!)).to.be.fulfilled
-    //         await sleep(200000)
-    //     })
+        it("stopEC2Instance should stop an instance", async () => {
+            await expect(stopEC2Instance(ec2, instance.InstanceId!)).to.be.fulfilled
+            await sleep(200000)
+        })
     
-    //     it("checkEC2Status should throw for an instance that is stopped", async () => {
-    //         await expect(checkEC2Status(ec2, instance.InstanceId!)).to.be.rejected
-    //     })
+        it("checkEC2Status should throw for an instance that is stopped", async () => {
+            await expect(checkEC2Status(ec2, instance.InstanceId!)).to.be.rejected
+        })
     
-    //     it("startEC2Instance should start an instance", async () => {
-    //         await expect(startEC2Instance(ec2, instance.InstanceId!)).to.be.fulfilled
-    //         await sleep(200000)
-    //     })
+        it("startEC2Instance should start an instance", async () => {
+            await expect(startEC2Instance(ec2, instance.InstanceId!)).to.be.fulfilled
+            await sleep(200000)
+        })
     
-    //     it("should get a different ip address after a restart", async () => {
-    //         const ip = getEC2Ip(ec2, instance.InstanceId!)
-    //         expect(previousIp).to.not.equal(ip)
-    //     })
+        it("should get a different ip address after a restart", async () => {
+            const ip = getEC2Ip(ec2, instance.InstanceId!)
+            expect(previousIp).to.not.equal(ip)
+        })
     
-    //     it("terminateEC2Instance should terminate an instance", async () => {
-    //         await expect(terminateEC2Instance(ec2, instance.InstanceId!)).to.be.fulfilled
-    //     })
-    // })
-
-    // describe("SSM", () => {
-    //     let ssmClient: SSMClient 
-    //     let commandId: string 
-    //     let ssmTestInstance: P0tionEC2Instance
-    //     beforeAll(async () => {
-    //         ssmClient = await createSSMClient()
-    //         ssmTestInstance = await createEC2Instance(ec2, [], "t2.micro", amiId, keyName, roleArn)
-    //         await sleep(250000)
-    //     })
-    //     it("run a command on a VM that is active", async () => {
-    //         commandId = await runCommandOnEC2(ssmClient, instance.InstanceId!, ["ls -la"])
-    //         expect(commandId).to.not.be.null 
-    //         await sleep(500)
-    //     })
-    //     it("should throw when trying to call a command on a VM that is not active", async () => {
-    //         await expect(runCommandOnEC2(ssmClient, "nonExistentOrOff", ["echo hello world"])).to.be.rejected
-    //     })
-    //     it("shuold retrieve the output of a command", async () => {
-    //         await sleep(20000)
-    //         const output = await retrieveCommandOutput(ssmClient, commandId, instance.InstanceId!)
-    //         expect(output.length).to.be.gt(0)
-    //     })
-    //     it("should throw when trying to retrieve the output of a non existent command", async () => {
-    //         await expect(retrieveCommandOutput(ssmClient, "nonExistentCommand", instance.InstanceId!)).to.be.rejected
-    //     })
-    //     afterAll(async () => {
-    //         await terminateEC2Instance(ec2, ssmTestInstance.InstanceId!)
-    //     })
-    // })
-
-    // afterAll(async () => {
-    //     await terminateEC2Instance(ec2, instance.InstanceId!)
-    // })
+        it("terminateEC2Instance should terminate an instance", async () => {
+            await expect(terminateEC2Instance(ec2, instance.InstanceId!)).to.be.fulfilled
+        })
+    })
+
+    describe("SSM", () => {
+        let ssmClient: SSMClient 
+        let commandId: string 
+        let ssmTestInstance: P0tionEC2Instance
+        beforeAll(async () => {
+            ssmClient = await createSSMClient()
+            ssmTestInstance = await createEC2Instance(ec2, [], "t2.micro", amiId, keyName, roleArn)
+            await sleep(250000)
+        })
+        it("run a command on a VM that is active", async () => {
+            commandId = await runCommandOnEC2(ssmClient, instance.InstanceId!, ["ls -la"])
+            expect(commandId).to.not.be.null 
+            await sleep(500)
+        })
+        it("should throw when trying to call a command on a VM that is not active", async () => {
+            await expect(runCommandOnEC2(ssmClient, "nonExistentOrOff", ["echo hello world"])).to.be.rejected
+        })
+        it("shuold retrieve the output of a command", async () => {
+            await sleep(20000)
+            const output = await retrieveCommandOutput(ssmClient, commandId, instance.InstanceId!)
+            expect(output.length).to.be.gt(0)
+        })
+        it("should throw when trying to retrieve the output of a non existent command", async () => {
+            await expect(retrieveCommandOutput(ssmClient, "nonExistentCommand", instance.InstanceId!)).to.be.rejected
+        })
+        afterAll(async () => {
+            await terminateEC2Instance(ec2, ssmTestInstance.InstanceId!)
+        })
+    })
+
+    afterAll(async () => {
+        await terminateEC2Instance(ec2, instance.InstanceId!)
+    })
 
     describe("Setup a ceremony that uses two VMs", () => {
         // Sample data for running the test.
@@ -130,6 +135,27 @@ describe("VMs", () => {
         let ceremonyId: string 
         const instancesToTerminate: string[] = []
 
+        const zkeyPath = `${cwd()}/packages/actions/test/data/artifacts/circuit_0000.zkey`
+        const potPath = `${cwd()}/packages/actions/test/data/artifacts/powersOfTau28_hez_final_02.ptau`
+        let storagePath = getZkeyStorageFilePath(
+            circuit.data.prefix!,
+            `${circuit.data.prefix}_${genesisZkeyIndex}.zkey`
+        )
+    
+        const potStoragePath = getPotStorageFilePath(circuit.data.files?.potFilename!)
+        const outputDirectory = `${cwd()}/packages/actions/test/data/artifacts/output`
+
+        if (envType === TestingEnvironment.PRODUCTION) {
+            // create dir structure
+            fs.mkdirSync(`${outputDirectory}/contribute/attestation`, { recursive: true })
+            fs.mkdirSync(`${outputDirectory}/contribute/transcripts`, { recursive: true })
+            fs.mkdirSync(`${outputDirectory}/contribute/zkeys`, { recursive: true })
+
+        }
+
+        // s3 objects we have to delete
+        const objectsToDelete = [potStoragePath, storagePath]
+
         beforeAll(async () => {
             // create 2 users the second is the coordinator
             for (let i = 0; i < 2; i++) {
@@ -145,6 +171,13 @@ describe("VMs", () => {
             // 1 create a bucket for the ceremony
             await signInWithEmailAndPassword(userAuth, users[1].data.email, passwords[1])
             await createS3Bucket(userFunctions, ceremonyBucket)
+
+
+            // zkey upload
+            await multiPartUpload(userFunctions, ceremonyBucket, storagePath, zkeyPath, streamChunkSizeInMb)
+            // pot upload
+            await multiPartUpload(userFunctions, ceremonyBucket, potStoragePath, potPath, streamChunkSizeInMb)
+            await signOut(userAuth)
         })
 
         afterAll(async () => {
@@ -153,7 +186,7 @@ describe("VMs", () => {
             }
         })
 
-        it("should create a ceremony and two VMs should spin up", async () => {
+        it.skip("should create a ceremony and two VMs should spin up", async () => {
             // 1. setup ceremony
             ceremonyId = await setupCeremony(userFunctions, ceremony.data, ceremony.data.prefix!, [circuit.data])
 
@@ -175,6 +208,112 @@ describe("VMs", () => {
             }
         })
 
-        it("should verify a contribution", async () => {})
+        it.skip("should verify a contribution", async () => {
+            // 1. login as user 2
+            await signInWithEmailAndPassword(userAuth, users[2].data.email, passwords[2])
+            await sleep(500)
+            // 2. get circuits for ceremony
+            const circuits = await getCeremonyCircuits(userFirestore, ceremonyId)
+            expect(circuits.length).to.be.gt(0)
+
+            // 3. register for cermeony
+            const canParticipate = await checkParticipantForCeremony(userFunctions, ceremonyId)
+            expect(canParticipate).to.be.true
+
+            // 4. entropy
+            const entropy = randomBytes(32).toString("hex")
+
+            // 5. get circuit to contribute to
+            const circuit = getCircuitBySequencePosition(circuits, 1)
+            expect(circuit).not.be.null
+
+            // 6. get circuit data
+            const currentProgress = circuit.data.waitingQueue.completedContributions
+            const currentZkeyIndex = formatZkeyIndex(currentProgress)
+            const nextZkeyIndex = formatZkeyIndex(currentProgress + 1)
+
+            // 7. download previous contribution
+            storagePath = getZkeyStorageFilePath(circuit.data.prefix, `${circuit.data.prefix}_${currentZkeyIndex}.zkey`)
+
+            const lastZkeyLocalFilePath = `${outputDirectory}/contribute/zkeys/${circuit.data.prefix}_${currentZkeyIndex}.zkey`
+            const nextZkeyLocalFilePath = `${outputDirectory}/contribute/zkeys/${circuit.data.prefix}_${nextZkeyIndex}.zkey`
+
+            const preSignedUrl = await generateGetObjectPreSignedUrl(userFunctions, ceremonyBucket, storagePath)
+            // @ts-ignore
+            const getResponse = await fetch(preSignedUrl)
+            await sleep(500)
+            // Write the file to disk.
+            fs.writeFileSync(lastZkeyLocalFilePath, await getResponse.buffer())
+            await sleep(500)
+            // 9. progress to next step
+            await progressToNextCircuitForContribution(userFunctions, ceremonyId)
+            await sleep(1000)
+
+            const transcriptLocalFilePath = `${outputDirectory}/${getTranscriptLocalFilePath(
+                `${circuit.data.prefix}_${nextZkeyIndex}.log`
+            )}`
+            const transcriptLogger = createCustomLoggerForFile(transcriptLocalFilePath)
+            // 10. do contribution
+            await zKey.contribute(lastZkeyLocalFilePath, nextZkeyLocalFilePath, users[2].uid, entropy, transcriptLogger)
+            await sleep(1000)
+
+            // read the contribution hash
+            const transcriptContents = fs.readFileSync(transcriptLocalFilePath, "utf-8").toString()
+            const matchContributionHash = transcriptContents.match(/Contribution.+Hash.+\n\t\t.+\n\t\t.+\n.+\n\t\t.+\n/)
+            const contributionHash = matchContributionHash?.at(0)?.replace("\n\t\t", "")!
+
+            await progressToNextContributionStep(userFunctions, ceremonyId)
+            await sleep(2000)
+            await permanentlyStoreCurrentContributionTimeAndHash(
+                userFunctions,
+                ceremonyId,
+                new Date().valueOf(),
+                contributionHash
+            )
+            await sleep(2000)
+
+            await progressToNextContributionStep(userFunctions, ceremonyId)
+            await sleep(1000)
+
+            const participant = await getDocumentById(
+                userFirestore,
+                getParticipantsCollectionPath(ceremonyId),
+                users[2].uid
+            )
+
+            // Upload
+            const nextZkeyStoragePath = getZkeyStorageFilePath(
+                circuit.data.prefix,
+                `${circuit.data.prefix}_${nextZkeyIndex}.zkey`
+            )
+            await multiPartUpload(
+                userFunctions,
+                ceremonyBucket,
+                nextZkeyStoragePath,
+                nextZkeyLocalFilePath,
+                streamChunkSizeInMb,
+                ceremony.uid,
+                participant.data()!.tempContributionData
+            )
+            await sleep(1000)
+
+            objectsToDelete.push(nextZkeyStoragePath)
+
+            // Execute contribution verification.
+            const tempCircuit = await getDocumentById(
+                userFirestore,
+                getCircuitsCollectionPath(ceremonyId),
+                circuit.id
+            )
+
+            await verifyContribution(
+                userFunctions,
+                ceremonyId,
+                tempCircuit,
+                ceremonyBucket,
+                users[2].uid,
+                String(process.env.FIREBASE_CF_URL_VERIFY_CONTRIBUTION)
+            )
+        })
     })
 })
diff --git a/packages/backend/src/functions/ceremony.ts b/packages/backend/src/functions/ceremony.ts
@@ -148,9 +148,6 @@ export const setupCeremony = functions
                 roleArn
             )
 
-            // @todo calculate how long it usually takes for the VM to be ready
-            await sleep(500000)
-
             // html encode circuit data.
             const encodedCircuit = htmlEncodeCircuitData(circuit)
             // Prepare tx to write circuit data.

Original file line number	Diff line number	Diff line change
`@@ -148,9 +148,6 @@ export const setupCeremony = functions`
`148`	`148`	`roleArn`
`149`	`149`	`)`
`150`	`150`
`151`		`- // @todo calculate how long it usually takes for the VM to be ready`
`152`		`- await sleep(500000)`
`153`		`-`
`154`	`151`	`// html encode circuit data.`
`155`	`152`	`const encodedCircuit = htmlEncodeCircuitData(circuit)`
`156`	`153`	`// Prepare tx to write circuit data.`