@enclave-e3/contracts 0.1.11 → 0.1.13

package/dist/test/Registry/CiphernodeRegistryOwnable.spec.js

@@ -9,11 +9,15 @@ import { network } from "hardhat";
 import { poseidon2 } from "poseidon-lite";
 import BondingRegistryModule from "../../ignition/modules/bondingRegistry";
 import CiphernodeRegistryModule from "../../ignition/modules/ciphernodeRegistry";
+import E3RefundManagerModule from "../../ignition/modules/e3RefundManager";
+import EnclaveModule from "../../ignition/modules/enclave";
 import EnclaveTicketTokenModule from "../../ignition/modules/enclaveTicketToken";
 import EnclaveTokenModule from "../../ignition/modules/enclaveToken";
+import MockDecryptionVerifierModule from "../../ignition/modules/mockDecryptionVerifier";
+import MockE3ProgramModule from "../../ignition/modules/mockE3Program";
 import MockStableTokenModule from "../../ignition/modules/mockStableToken";
 import SlashingManagerModule from "../../ignition/modules/slashingManager";
-import { BondingRegistry__factory as BondingRegistryFactory, CiphernodeRegistryOwnable__factory as CiphernodeRegistryFactory, } from "../../types";
+import { BondingRegistry__factory as BondingRegistryFactory, CiphernodeRegistryOwnable__factory as CiphernodeRegistryFactory, Enclave__factory as EnclaveFactory, } from "../../types";
 const AddressOne = "0x0000000000000000000000000000000000000001";
 const AddressTwo = "0x0000000000000000000000000000000000000002";
 const AddressThree = "0x0000000000000000000000000000000000000003";
@@ -50,6 +54,12 @@ describe("CiphernodeRegistryOwnable", function () {
     async function setup() {
         const [owner, notTheOwner, operator1, operator2] = await ethers.getSigners();
         const ownerAddress = await owner.getAddress();
+        const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+        const polynomial_degree = ethers.toBigInt(2048);
+        const plaintext_modulus = ethers.toBigInt(1032193);
+        const moduli = [ethers.toBigInt("18014398492704769")];
+        const encodedE3ProgramParams = abiCoder.encode(["uint256", "uint256", "uint256[]"], [polynomial_degree, plaintext_modulus, moduli]);
+        const encryptionSchemeId = "0x2c2a814a0495f913a3a312fc4771e37552bc14f8a2d4075a08122d356f0849c6";
         const usdcContract = await ignition.deploy(MockStableTokenModule, {
             parameters: {
                 MockUSDC: {
@@ -96,10 +106,44 @@ describe("CiphernodeRegistryOwnable", function () {
                 },
             },
         });
+        const enclaveContract = await ignition.deploy(EnclaveModule, {
+            parameters: {
+                Enclave: {
+                    params: encodedE3ProgramParams,
+                    owner: ownerAddress,
+                    maxDuration: 60 * 60 * 24 * 30, // 30 days
+                    registry: AddressOne, // placeholder, will be updated
+                    bondingRegistry: await bondingRegistryContract.bondingRegistry.getAddress(),
+                    e3RefundManager: AddressOne, // placeholder, will be updated
+                    feeToken: await usdcContract.mockUSDC.getAddress(),
+                    timeoutConfig: {
+                        committeeFormationWindow: 3600,
+                        dkgWindow: 3600,
+                        computeWindow: 3600,
+                        decryptionWindow: 3600,
+                        gracePeriod: 300,
+                    },
+                },
+            },
+        });
+        const enclaveAddress = await enclaveContract.enclave.getAddress();
+        const enclave = EnclaveFactory.connect(enclaveAddress, owner);
+        const e3RefundManagerContract = await ignition.deploy(E3RefundManagerModule, {
+            parameters: {
+                E3RefundManager: {
+                    owner: ownerAddress,
+                    enclave: enclaveAddress,
+                    treasury: ownerAddress,
+                },
+            },
+        });
+        const e3RefundManagerAddress = await e3RefundManagerContract.e3RefundManager.getAddress();
+        await enclave.setE3RefundManager(e3RefundManagerAddress);
+        // Deploy CiphernodeRegistry with real Enclave address
         const registryContract = await ignition.deploy(CiphernodeRegistryModule, {
             parameters: {
                 CiphernodeRegistry: {
-                    enclaveAddress: ownerAddress,
+                    enclaveAddress: enclaveAddress,
                     owner: ownerAddress,
                     submissionWindow: SORTITION_SUBMISSION_WINDOW,
                 },
@@ -107,11 +151,20 @@ describe("CiphernodeRegistryOwnable", function () {
         });
         const registryAddress = await registryContract.cipherNodeRegistry.getAddress();
         const registry = CiphernodeRegistryFactory.connect(registryAddress, owner);
+        // Update Enclave with correct registry address
+        await enclave.setCiphernodeRegistry(registryAddress);
         const bondingRegistry = BondingRegistryFactory.connect(await bondingRegistryContract.bondingRegistry.getAddress(), owner);
         await ticketTokenContract.enclaveTicketToken.setRegistry(await bondingRegistry.getAddress());
         await bondingRegistry.setRegistry(registryAddress);
         await bondingRegistry.setSlashingManager(await slashingManagerContract.slashingManager.getAddress());
         await slashingManagerContract.slashingManager.setBondingRegistry(await bondingRegistry.getAddress());
+        // Set up mock E3Program and DecryptionVerifier for Enclave
+        const mockE3Program = await ignition.deploy(MockE3ProgramModule);
+        const mockDecryptionVerifier = await ignition.deploy(MockDecryptionVerifierModule);
+        await enclave.enableE3Program(await mockE3Program.mockE3Program.getAddress());
+        await enclave.setE3ProgramsParams([encodedE3ProgramParams]);
+        await enclave.setDecryptionVerifier(encryptionSchemeId, await mockDecryptionVerifier.mockDecryptionVerifier.getAddress());
+        await bondingRegistry.setRewardDistributor(enclaveAddress);
         await registry.setBondingRegistry(await bondingRegistry.getAddress());
         const tree = new LeanIMT(hash);
         const licenseToken = enclTokenContract.enclaveToken;
@@ -129,17 +182,42 @@ describe("CiphernodeRegistryOwnable", function () {
             operator1,
             operator2,
             registry,
+            enclave,
             bondingRegistry,
             licenseToken,
             ticketToken,
             usdcToken,
             tree,
+            mockE3Program,
+            mockDecryptionVerifier,
             request: {
-                e3Id: 1,
+                e3Id: 0,
                 threshold: [2, 2],
             },
         };
     }
+    // Helper to make a request through the Enclave contract
+    async function makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier, signer) {
+        const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+        const polynomial_degree = ethers.toBigInt(2048);
+        const plaintext_modulus = ethers.toBigInt(1032193);
+        const moduli = [ethers.toBigInt("18014398492704769")];
+        const encodedE3ProgramParams = abiCoder.encode(["uint256", "uint256", "uint256[]"], [polynomial_degree, plaintext_modulus, moduli]);
+        const currentTime = await networkHelpers.time.latest();
+        const requestParams = {
+            threshold: [2, 2],
+            inputWindow: [currentTime + 100, currentTime + 300],
+            e3Program: await mockE3Program.mockE3Program.getAddress(),
+            e3ProgramParams: encodedE3ProgramParams,
+            computeProviderParams: abiCoder.encode(["address"], [await mockDecryptionVerifier.mockDecryptionVerifier.getAddress()]),
+            customParams: abiCoder.encode(["address"], ["0x1234567890123456789012345678901234567890"]),
+        };
+        const fee = await enclave.getE3Quote(requestParams);
+        const tokenContract = signer ? usdcToken.connect(signer) : usdcToken;
+        const enclaveContract = signer ? enclave.connect(signer) : enclave;
+        await tokenContract.approve(await enclave.getAddress(), fee);
+        return enclaveContract.request(requestParams);
+    }
     describe("constructor / initialize()", function () {
         it("correctly sets `_owner` and `enclave` ", async function () {
             const poseidonFactory = await ethers.getContractFactory("PoseidonT3");
@@ -169,68 +247,61 @@ describe("CiphernodeRegistryOwnable", function () {
         });
     });
     describe("requestCommittee()", function () {
-        it("reverts if committee has already been requested for given e3Id", async function () {
-            const { registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, 0, request.threshold);
-            await expect(registry.requestCommittee(request.e3Id, 0, request.threshold)).to.be.revertedWithCustomError(registry, "CommitteeAlreadyRequested");
+        it("stores rootAt for the requested e3Id after a successful request", async function () {
+            const { registry, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, } = await loadFixture(setup);
+            // Request through Enclave
+            await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
+            expect(await registry.rootAt(0)).to.equal(await registry.root());
         });
         it("stores the root of the ciphernode registry at the time of the request", async function () {
-            const { registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, 0, request.threshold);
-            expect(await registry.rootAt(request.e3Id)).to.equal(await registry.root());
+            const { registry, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
+            expect(await registry.rootAt(0)).to.equal(await registry.root());
         });
         it("emits a CommitteeRequested event", async function () {
-            const { registry, request } = await loadFixture(setup);
-            const tx = await registry.requestCommittee(request.e3Id, 0n, request.threshold);
-            const receipt = await tx.wait();
-            if (!receipt)
-                throw new Error("Transaction failed");
-            const sWindow = await registry.sortitionSubmissionWindow();
-            const block = await ethers.provider.getBlock(receipt.blockNumber);
-            if (!block)
-                throw new Error("Block not found");
-            const expectedBlockNumber = BigInt(receipt.blockNumber);
-            const expectedDeadline = BigInt(block.timestamp) + sWindow;
-            await expect(tx)
-                .to.emit(registry, "CommitteeRequested")
-                .withArgs(request.e3Id, 0n, request.threshold, expectedBlockNumber, expectedDeadline);
+            const { registry, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, } = await loadFixture(setup);
+            const tx = await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
+            // Should emit CommitteeRequested from registry
+            await expect(tx).to.emit(registry, "CommitteeRequested");
         });
         it("returns true if the request is successful", async function () {
-            const { registry, request } = await loadFixture(setup);
-            expect(await registry.requestCommittee.staticCall(request.e3Id, 0, request.threshold)).to.be.true;
+            const { registry, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, } = await loadFixture(setup);
+            // We can verify by checking that root is stored after request
+            await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
+            expect(await registry.rootAt(0)).to.not.equal(0);
         });
     });
     describe("publishCommittee()", function () {
         it("reverts if the caller is not the owner", async function () {
-            const { registry, request, notTheOwner, operator1, operator2 } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, 0, request.threshold);
-            await registry.connect(operator1).submitTicket(request.e3Id, 1);
-            await registry.connect(operator2).submitTicket(request.e3Id, 1);
-            await finalizeCommitteeAfterWindow(registry, request.e3Id);
+            const { registry, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, notTheOwner, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
+            await registry.connect(operator1).submitTicket(0, 1);
+            await registry.connect(operator2).submitTicket(0, 1);
+            await finalizeCommitteeAfterWindow(registry, 0);
             await expect(registry
                 .connect(notTheOwner)
-                .publishCommittee(request.e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, dataHash)).to.be.revertedWithCustomError(registry, "OwnableUnauthorizedAccount");
+                .publishCommittee(0, [await operator1.getAddress(), await operator2.getAddress()], data, dataHash)).to.be.revertedWithCustomError(registry, "OwnableUnauthorizedAccount");
         });
         it("stores the public key of the committee", async function () {
-            const { registry, request, operator1, operator2 } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, 0, request.threshold);
+            const { registry, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
             await networkHelpers.mine(1);
-            await registry.connect(operator1).submitTicket(request.e3Id, 1);
-            await registry.connect(operator2).submitTicket(request.e3Id, 1);
-            await finalizeCommitteeAfterWindow(registry, request.e3Id);
-            await registry.publishCommittee(request.e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, dataHash);
-            expect(await registry.committeePublicKey(request.e3Id)).to.equal(dataHash);
+            await registry.connect(operator1).submitTicket(0, 1);
+            await registry.connect(operator2).submitTicket(0, 1);
+            await finalizeCommitteeAfterWindow(registry, 0);
+            await registry.publishCommittee(0, [await operator1.getAddress(), await operator2.getAddress()], data, dataHash);
+            expect(await registry.committeePublicKey(0)).to.equal(dataHash);
         });
         it("emits a CommitteePublished event", async function () {
-            const { registry, request, operator1, operator2 } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, 0, request.threshold);
+            const { registry, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
             // Submit tickets from both operators and finalize
-            await registry.connect(operator1).submitTicket(request.e3Id, 1);
-            await registry.connect(operator2).submitTicket(request.e3Id, 1);
-            await finalizeCommitteeAfterWindow(registry, request.e3Id);
-            await expect(await registry.publishCommittee(request.e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, dataHash))
+            await registry.connect(operator1).submitTicket(0, 1);
+            await registry.connect(operator2).submitTicket(0, 1);
+            await finalizeCommitteeAfterWindow(registry, 0);
+            await expect(await registry.publishCommittee(0, [await operator1.getAddress(), await operator2.getAddress()], data, dataHash))
                 .to.emit(registry, "CommitteePublished")
-                .withArgs(request.e3Id, [await operator1.getAddress(), await operator2.getAddress()], data);
+                .withArgs(0, [await operator1.getAddress(), await operator2.getAddress()], data);
         });
     });
     describe("addCiphernode()", function () {
@@ -318,18 +389,20 @@ describe("CiphernodeRegistryOwnable", function () {
     });
     describe("committeePublicKey()", function () {
         it("returns the public key of the committee for the given e3Id", async function () {
-            const { registry, request, operator1, operator2 } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, 0, request.threshold);
-            await registry.connect(operator1).submitTicket(request.e3Id, 1);
-            await registry.connect(operator2).submitTicket(request.e3Id, 1);
-            await finalizeCommitteeAfterWindow(registry, request.e3Id);
-            await registry.publishCommittee(request.e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, dataHash);
-            expect(await registry.committeePublicKey(request.e3Id)).to.equal(dataHash);
+            const { registry, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, operator1, operator2, } = await loadFixture(setup);
+            const e3Id = 0;
+            await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
+            await registry.connect(operator1).submitTicket(e3Id, 1);
+            await registry.connect(operator2).submitTicket(e3Id, 1);
+            await finalizeCommitteeAfterWindow(registry, e3Id);
+            await registry.publishCommittee(e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, dataHash);
+            expect(await registry.committeePublicKey(e3Id)).to.equal(dataHash);
         });
         it("reverts if the committee has not been published", async function () {
-            const { registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, 0, request.threshold);
-            await expect(registry.committeePublicKey(request.e3Id)).to.be.revertedWithCustomError(registry, "CommitteeNotPublished");
+            const { registry, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, } = await loadFixture(setup);
+            const e3Id = 0;
+            await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
+            await expect(registry.committeePublicKey(e3Id)).to.be.revertedWithCustomError(registry, "CommitteeNotPublished");
         });
     });
     describe("isCiphernodeEligible()", function () {
@@ -360,9 +433,10 @@ describe("CiphernodeRegistryOwnable", function () {
     });
     describe("rootAt()", function () {
         it("returns the root of the ciphernode registry merkle tree at the given e3Id", async function () {
-            const { registry, tree, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, 0, request.threshold);
-            expect(await registry.rootAt(request.e3Id)).to.equal(tree.root);
+            const { registry, tree, enclave, usdcToken, mockE3Program, mockDecryptionVerifier, } = await loadFixture(setup);
+            const e3Id = 0;
+            await makeRequest(enclave, usdcToken, mockE3Program, mockDecryptionVerifier);
+            expect(await registry.rootAt(e3Id)).to.equal(tree.root);
         });
     });
     describe("treeSize()", function () {