@enclave-e3/contracts 0.1.4 → 0.1.6

package/dist/test/Enclave.spec.js

@@ -7,19 +7,23 @@ import { LeanIMT } from "@zk-kit/lean-imt";
 import { expect } from "chai";
 import { network } from "hardhat";
 import { poseidon2 } from "poseidon-lite";
+import BondingRegistryModule from "../ignition/modules/bondingRegistry";
+import CiphernodeRegistryModule from "../ignition/modules/ciphernodeRegistry";
 import EnclaveModule from "../ignition/modules/enclave";
-import MockCiphernodeRegistryModule from "../ignition/modules/mockCiphernodeRegistry";
+import EnclaveTicketTokenModule from "../ignition/modules/enclaveTicketToken";
+import EnclaveTokenModule from "../ignition/modules/enclaveToken";
 import MockCiphernodeRegistryEmptyKeyModule from "../ignition/modules/mockCiphernodeRegistryEmptyKey";
 import mockComputeProviderModule from "../ignition/modules/mockComputeProvider";
 import MockDecryptionVerifierModule from "../ignition/modules/mockDecryptionVerifier";
 import MockE3ProgramModule from "../ignition/modules/mockE3Program";
-import MockInputValidatorModule from "../ignition/modules/mockInputValidator";
-import NaiveRegistryFilterModule from "../ignition/modules/naiveRegistryFilter";
-import { CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnableFactory, Enclave__factory as EnclaveFactory, NaiveRegistryFilter__factory as NaiveRegistryFilterFactory, } from "../types";
+import MockStableTokenModule from "../ignition/modules/mockStableToken";
+import SlashingManagerModule from "../ignition/modules/slashingManager";
+import { BondingRegistry__factory as BondingRegistryFactory, CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnableFactory, Enclave__factory as EnclaveFactory, MockUSDC__factory as MockUSDCFactory, } from "../types";
 const { ethers, ignition, networkHelpers } = await network.connect();
 const { loadFixture, time, mine } = networkHelpers;
 describe("Enclave", function () {
     const THIRTY_DAYS_IN_SECONDS = 60 * 60 * 24 * 30;
+    const SORTITION_SUBMISSION_WINDOW = 10;
     const addressOne = "0x0000000000000000000000000000000000000001";
     const AddressTwo = "0x0000000000000000000000000000000000000002";
     const encryptionSchemeId = "0x2c2a814a0495f913a3a312fc4771e37552bc14f8a2d4075a08122d356f0849c6";
@@ -34,9 +38,89 @@ describe("Enclave", function () {
     const proof = "0x1337";
     // Hash function used to compute the tree nodes.
     const hash = (a, b) => poseidon2([a, b]);
+    const setupAndPublishCommittee = async (registry, e3Id, nodes, publicKey, operator1, operator2) => {
+        await registry.connect(operator1).submitTicket(e3Id, 1);
+        await registry.connect(operator2).submitTicket(e3Id, 1);
+        await time.increase(SORTITION_SUBMISSION_WINDOW + 1);
+        await registry.finalizeCommittee(e3Id);
+        await registry.publishCommittee(e3Id, nodes, publicKey);
+    };
+    // Helper function to approve USDC and make request
+    const makeRequest = async (enclave, usdcToken, requestParams, signer) => {
+        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);
+    };
+    async function setupOperatorForSortition(operator, bondingRegistry, licenseToken, usdcToken, ticketToken, registry) {
+        const operatorAddress = await operator.getAddress();
+        await licenseToken.mintAllocation(operatorAddress, ethers.parseEther("10000"), "Test allocation");
+        await usdcToken.mint(operatorAddress, ethers.parseUnits("100000", 6));
+        await licenseToken
+            .connect(operator)
+            .approve(await bondingRegistry.getAddress(), ethers.parseEther("2000"));
+        await bondingRegistry
+            .connect(operator)
+            .bondLicense(ethers.parseEther("1000"));
+        await bondingRegistry.connect(operator).registerOperator();
+        const ticketAmount = ethers.parseUnits("100", 6);
+        await usdcToken
+            .connect(operator)
+            .approve(await ticketToken.getAddress(), ticketAmount);
+        await bondingRegistry.connect(operator).addTicketBalance(ticketAmount);
+        await registry.addCiphernode(operatorAddress);
+    }
     const setup = async () => {
-        const [owner, notTheOwner] = await ethers.getSigners();
+        const [owner, notTheOwner, operator1, operator2] = await ethers.getSigners();
         const ownerAddress = await owner.getAddress();
+        const usdcContract = await ignition.deploy(MockStableTokenModule, {
+            parameters: {
+                MockUSDC: {
+                    initialSupply: 1000000,
+                },
+            },
+        });
+        const usdcToken = MockUSDCFactory.connect(await usdcContract.mockUSDC.getAddress(), owner);
+        const enclTokenContract = await ignition.deploy(EnclaveTokenModule, {
+            parameters: {
+                EnclaveToken: {
+                    owner: ownerAddress,
+                },
+            },
+        });
+        const ticketTokenContract = await ignition.deploy(EnclaveTicketTokenModule, {
+            parameters: {
+                EnclaveTicketToken: {
+                    baseToken: await usdcToken.getAddress(),
+                    registry: addressOne,
+                    owner: ownerAddress,
+                },
+            },
+        });
+        const slashingManagerContract = await ignition.deploy(SlashingManagerModule, {
+            parameters: {
+                SlashingManager: {
+                    admin: ownerAddress,
+                    bondingRegistry: addressOne,
+                },
+            },
+        });
+        const bondingRegistryContract = await ignition.deploy(BondingRegistryModule, {
+            parameters: {
+                BondingRegistry: {
+                    owner: ownerAddress,
+                    ticketToken: await ticketTokenContract.enclaveTicketToken.getAddress(),
+                    licenseToken: await enclTokenContract.enclaveToken.getAddress(),
+                    registry: addressOne,
+                    slashedFundsTreasury: ownerAddress,
+                    ticketPrice: ethers.parseUnits("10", 6),
+                    licenseRequiredBond: ethers.parseEther("1000"),
+                    minTicketBalance: 5,
+                    exitDelay: 7 * 24 * 60 * 60,
+                },
+            },
+        });
         const enclaveContract = await ignition.deploy(EnclaveModule, {
             parameters: {
                 Enclave: {
@@ -44,63 +128,80 @@ describe("Enclave", function () {
                     owner: ownerAddress,
                     maxDuration: THIRTY_DAYS_IN_SECONDS,
                     registry: addressOne,
+                    bondingRegistry: await bondingRegistryContract.bondingRegistry.getAddress(),
+                    feeToken: await usdcToken.getAddress(),
                 },
             },
         });
         const enclaveAddress = await enclaveContract.enclave.getAddress();
-        const ciphernodeRegistry = await ignition.deploy(MockCiphernodeRegistryModule);
-        const ciphernodeRegistryAddress = await ciphernodeRegistry.mockCiphernodeRegistry.getAddress();
-        const naiveRegistryFilter = await ignition.deploy(NaiveRegistryFilterModule, {
+        const ciphernodeRegistry = await ignition.deploy(CiphernodeRegistryModule, {
             parameters: {
-                NaiveRegistryFilter: {
-                    ciphernodeRegistryAddress,
+                CiphernodeRegistry: {
+                    enclaveAddress: enclaveAddress,
                     owner: ownerAddress,
+                    submissionWindow: SORTITION_SUBMISSION_WINDOW,
                 },
             },
         });
-        const naiveRegistryFilterAddress = await naiveRegistryFilter.naiveRegistryFilter.getAddress();
+        const ciphernodeRegistryAddress = await ciphernodeRegistry.cipherNodeRegistry.getAddress();
         const enclave = EnclaveFactory.connect(enclaveAddress, owner);
         const ciphernodeRegistryContract = CiphernodeRegistryOwnableFactory.connect(ciphernodeRegistryAddress, owner);
-        const naiveRegistryFilterContract = NaiveRegistryFilterFactory.connect(naiveRegistryFilterAddress, owner);
+        const bondingRegistry = BondingRegistryFactory.connect(await bondingRegistryContract.bondingRegistry.getAddress(), owner);
         const registryAddress = await enclave.ciphernodeRegistry();
         if (registryAddress !== ciphernodeRegistryAddress) {
             await enclave.setCiphernodeRegistry(ciphernodeRegistryAddress);
         }
+        await ciphernodeRegistryContract.setBondingRegistry(await bondingRegistry.getAddress());
+        await ticketTokenContract.enclaveTicketToken.setRegistry(await bondingRegistry.getAddress());
+        await bondingRegistry.setRegistry(ciphernodeRegistryAddress);
+        await bondingRegistry.setSlashingManager(await slashingManagerContract.slashingManager.getAddress());
+        await slashingManagerContract.slashingManager.setBondingRegistry(await bondingRegistry.getAddress());
+        await bondingRegistry.setRewardDistributor(enclaveAddress);
+        const tree = new LeanIMT(hash);
+        const licenseToken = enclTokenContract.enclaveToken;
+        const ticketToken = ticketTokenContract.enclaveTicketToken;
+        await licenseToken.setTransferRestriction(false);
+        await setupOperatorForSortition(operator1, bondingRegistry, licenseToken, usdcToken, ticketToken, ciphernodeRegistryContract);
+        tree.insert(BigInt(await operator1.getAddress()));
+        await setupOperatorForSortition(operator2, bondingRegistry, licenseToken, usdcToken, ticketToken, ciphernodeRegistryContract);
+        tree.insert(BigInt(await operator2.getAddress()));
+        await mine(1);
         const mockComputeProvider = await ignition.deploy(mockComputeProviderModule);
         const decryptionVerifier = await ignition.deploy(MockDecryptionVerifierModule);
-        const inputValidator = await ignition.deploy(MockInputValidatorModule);
-        const e3Program = await ignition.deploy(MockE3ProgramModule, {
-            parameters: {
-                MockE3Program: {
-                    mockInputValidator: await inputValidator.mockInputValidator.getAddress(),
-                },
-            },
-        });
+        const e3Program = await ignition.deploy(MockE3ProgramModule);
         await enclave.enableE3Program(await e3Program.mockE3Program.getAddress());
         await enclave.setE3ProgramsParams([encodedE3ProgramParams]);
         await enclave.setDecryptionVerifier(encryptionSchemeId, await decryptionVerifier.mockDecryptionVerifier.getAddress());
         const request = {
-            filter: await naiveRegistryFilterContract.getAddress(),
             threshold: [2, 2],
-            startTime: [await time.latest(), (await time.latest()) + 100],
+            startWindow: [await time.latest(), (await time.latest()) + 100],
             duration: time.duration.days(30),
             e3Program: await e3Program.mockE3Program.getAddress(),
             e3ProgramParams: encodedE3ProgramParams,
             computeProviderParams: abiCoder.encode(["address"], [await decryptionVerifier.mockDecryptionVerifier.getAddress()]),
+            customParams: abiCoder.encode(["address"], ["0x1234567890123456789012345678901234567890"]),
         };
+        await usdcToken.mint(ownerAddress, ethers.parseUnits("1000000", 6));
+        await usdcToken.mint(await notTheOwner.getAddress(), ethers.parseUnits("1000000", 6));
         return {
             enclave,
             ciphernodeRegistryContract,
-            naiveRegistryFilterContract,
+            bondingRegistry: bondingRegistry,
+            ticketToken: ticketTokenContract.enclaveTicketToken,
+            licenseToken: licenseToken,
+            usdcToken,
+            slashingManager: slashingManagerContract.slashingManager,
+            tree,
             mocks: {
                 decryptionVerifier: decryptionVerifier.mockDecryptionVerifier,
-                inputValidator: inputValidator.mockInputValidator,
                 e3Program: e3Program.mockE3Program,
                 mockComputeProvider: mockComputeProvider.mockComputeProvider,
             },
             request,
             owner,
             notTheOwner,
+            operator1,
+            operator2,
         };
     };
     describe("constructor / initialize()", function () {
@@ -224,22 +325,21 @@ describe("Enclave", function () {
                 .withArgs(1);
         });
         it("returns correct E3 details", async function () {
-            const { enclave, request, mocks, naiveRegistryFilterContract } = await loadFixture(setup);
-            await enclave.request({
-                filter: await naiveRegistryFilterContract.getAddress(),
+            const { enclave, request, usdcToken } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             const e3 = await enclave.getE3(0);
             expect(e3.threshold).to.deep.equal(request.threshold);
             expect(e3.expiration).to.equal(0n);
             expect(e3.e3Program).to.equal(request.e3Program);
             expect(e3.e3ProgramParams).to.equal(request.e3ProgramParams);
-            expect(e3.inputValidator).to.equal(await mocks.inputValidator.getAddress());
             expect(e3.decryptionVerifier).to.equal(abiCoder.decode(["address"], request.computeProviderParams)[0]);
             expect(e3.committeePublicKey).to.equal(ethers.ZeroHash);
             expect(e3.ciphertextOutput).to.equal(ethers.ZeroHash);
@@ -382,145 +482,150 @@ describe("Enclave", function () {
         });
     });
     describe("request()", function () {
-        it("reverts if msg.value is 0", async function () {
-            const { enclave, request } = await loadFixture(setup);
+        it("reverts if USDC allowance is insufficient", async function () {
+            const { enclave, request, usdcToken } = await loadFixture(setup);
             await expect(enclave.request({
-                filter: request.filter,
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            })).to.be.revertedWithCustomError(enclave, "PaymentRequired");
+                customParams: request.customParams,
+            })).to.be.revertedWithCustomError(usdcToken, "ERC20InsufficientAllowance");
         });
         it("reverts if threshold is 0", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken } = await loadFixture(setup);
+            const fee = await enclave.getE3Quote({
+                threshold: [0, 2],
+                startWindow: request.startWindow,
+                duration: request.duration,
+                e3Program: request.e3Program,
+                e3ProgramParams: request.e3ProgramParams,
+                computeProviderParams: request.computeProviderParams,
+                customParams: request.customParams,
+            });
+            await usdcToken.approve(await enclave.getAddress(), fee);
             await expect(enclave.request({
-                filter: request.filter,
                 threshold: [0, 2],
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 })).to.be.revertedWithCustomError(enclave, "InvalidThreshold");
+                customParams: request.customParams,
+            }))
+                .to.be.revertedWithCustomError(enclave, "InvalidThreshold")
+                .withArgs([0, 2]);
         });
         it("reverts if threshold is greater than number", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await expect(enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken } = await loadFixture(setup);
+            await expect(makeRequest(enclave, usdcToken, {
                 threshold: [3, 2],
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 })).to.be.revertedWithCustomError(enclave, "InvalidThreshold");
+                customParams: request.customParams,
+            }))
+                .to.be.revertedWithCustomError(enclave, "InvalidThreshold")
+                .withArgs([3, 2]);
         });
         it("reverts if duration is 0", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await expect(enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken } = await loadFixture(setup);
+            await expect(makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: 0,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 })).to.be.revertedWithCustomError(enclave, "InvalidDuration");
+                customParams: request.customParams,
+            }))
+                .to.be.revertedWithCustomError(enclave, "InvalidDuration")
+                .withArgs(0);
         });
         it("reverts if duration is greater than maxDuration", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await expect(enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken } = await loadFixture(setup);
+            await expect(makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: time.duration.days(31),
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 })).to.be.revertedWithCustomError(enclave, "InvalidDuration");
+                customParams: request.customParams,
+            }))
+                .to.be.revertedWithCustomError(enclave, "InvalidDuration")
+                .withArgs(time.duration.days(31));
         });
         it("reverts if E3 Program is not enabled", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await expect(enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken } = await loadFixture(setup);
+            await expect(makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: ethers.ZeroAddress,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 }))
+                customParams: request.customParams,
+            }))
                 .to.be.revertedWithCustomError(enclave, "E3ProgramNotAllowed")
                 .withArgs(ethers.ZeroAddress);
         });
         it("reverts if given encryption scheme is not enabled", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken } = await loadFixture(setup);
             await enclave.disableEncryptionScheme(encryptionSchemeId);
-            await expect(enclave.request({
-                filter: request.filter,
+            await expect(makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 }))
+                customParams: request.customParams,
+            }))
                 .to.be.revertedWithCustomError(enclave, "InvalidEncryptionScheme")
                 .withArgs(encryptionSchemeId);
         });
-        it("reverts if committee selection fails", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await expect(enclave.request({
-                filter: AddressTwo,
-                threshold: request.threshold,
-                startWindow: request.startTime,
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 })).to.be.revertedWithCustomError(enclave, "CommitteeSelectionFailed");
-        });
         it("instantiates a new E3", async function () {
-            const { enclave, request, mocks } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             const e3 = await enclave.getE3(0);
             const block = await ethers.provider.getBlock("latest").catch((e) => e);
             expect(e3.threshold).to.deep.equal(request.threshold);
             expect(e3.expiration).to.equal(0n);
             expect(e3.e3Program).to.equal(request.e3Program);
             expect(e3.requestBlock).to.equal(block.number);
-            expect(e3.inputValidator).to.equal(await mocks.inputValidator.getAddress());
             expect(e3.decryptionVerifier).to.equal(abiCoder.decode(["address"], request.computeProviderParams)[0]);
             expect(e3.committeePublicKey).to.equal(ethers.ZeroHash);
             expect(e3.ciphertextOutput).to.equal(ethers.ZeroHash);
             expect(e3.plaintextOutput).to.equal("0x");
         });
         it("emits E3Requested event", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            const tx = await enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken } = await loadFixture(setup);
+            const tx = await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             const e3 = await enclave.getE3(0);
             await expect(tx)
                 .to.emit(enclave, "E3Requested")
-                .withArgs(0, e3, request.filter, request.e3Program);
+                .withArgs(0, e3, request.e3Program);
         });
     });
     describe("activate()", function () {
@@ -531,155 +636,144 @@ describe("Enclave", function () {
                 .withArgs(0);
         });
         it("reverts if E3 has already been activated", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, 0, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
             await expect(enclave.getE3(0)).to.not.be.revert(ethers);
-            await expect(enclave.activate(0, ethers.ZeroHash)).to.not.be.revert(ethers);
-            await expect(enclave.activate(0, ethers.ZeroHash))
+            await expect(enclave.activate(0, data)).to.not.be.revert(ethers);
+            await expect(enclave.activate(0, data))
                 .to.be.revertedWithCustomError(enclave, "E3AlreadyActivated")
                 .withArgs(0);
         });
         it("reverts if E3 is not yet ready to start", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken } = await loadFixture(setup);
             const startTime = [
                 (await time.latest()) + 1000,
                 (await time.latest()) + 2000,
             ];
-            await enclave.request({
-                filter: request.filter,
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
                 startWindow: startTime,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             await expect(enclave.activate(0, ethers.ZeroHash)).to.be.revertedWithCustomError(enclave, "E3NotReady");
         });
         it("reverts if E3 start has expired", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            const startTime = [
-                (await time.latest()) + 1,
-                (await time.latest()) + 1000,
-            ];
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
+            const e3Id = 0;
+            const currentTime = await time.latest();
+            const startTime = [currentTime + 10, currentTime + 100];
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: startTime,
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
             await mine(2, { interval: 2000 });
-            await expect(enclave.activate(0, ethers.ZeroHash)).to.be.revertedWithCustomError(enclave, "E3Expired");
+            await expect(enclave.activate(e3Id, data)).to.be.revertedWithCustomError(enclave, "E3Expired");
         });
         it("reverts if ciphernodeRegistry does not return a public key", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken } = await loadFixture(setup);
             const startTime = [
                 (await time.latest()) + 1000,
                 (await time.latest()) + 2000,
             ];
-            await enclave.request({
-                filter: request.filter,
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
                 startWindow: startTime,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             await expect(enclave.activate(0, ethers.ZeroHash)).to.be.revertedWithCustomError(enclave, "E3NotReady");
         });
         it("reverts if E3 start has expired", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            const startTime = [await time.latest(), (await time.latest()) + 1];
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
+            const e3Id = 0;
+            const currentTime = await time.latest();
+            const startTime = [currentTime + 5, currentTime + 50];
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: startTime,
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await mine(1, { interval: 1000 });
-            await expect(enclave.activate(0, ethers.ZeroHash)).to.be.revertedWithCustomError(enclave, "E3Expired");
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await time.increaseTo(currentTime + request.duration + 100);
+            await expect(enclave.activate(e3Id, data)).to.be.revertedWithCustomError(enclave, "E3Expired");
         });
         it("reverts if ciphernodeRegistry does not return a public key", async function () {
-            const { enclave, request, naiveRegistryFilterContract } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
-                startWindow: request.startTime,
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+            const { enclave, request, ciphernodeRegistryContract, usdcToken, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, request);
             const prevRegistry = await enclave.ciphernodeRegistry();
             const reg = await ignition.deploy(MockCiphernodeRegistryEmptyKeyModule);
             const nextRegistry = await reg.mockCiphernodeRegistryEmptyKey.getAddress();
             await enclave.setCiphernodeRegistry(nextRegistry);
-            await naiveRegistryFilterContract.setRegistry(nextRegistry);
             await expect(enclave.activate(0, ethers.ZeroHash)).to.be.revertedWithCustomError(enclave, "CommitteeSelectionFailed");
             await enclave.setCiphernodeRegistry(prevRegistry);
-            await expect(enclave.activate(0, ethers.ZeroHash)).not.to.be.revert(ethers);
+            await setupAndPublishCommittee(ciphernodeRegistryContract, 0, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await expect(enclave.activate(0, data)).not.to.be.revert(ethers);
         });
         it("sets committeePublicKey correctly", async () => {
-            const { enclave, request, ciphernodeRegistryContract } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
+            const { enclave, request, ciphernodeRegistryContract, usdcToken, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             const e3Id = 0;
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
             const publicKey = await ciphernodeRegistryContract.committeePublicKey(e3Id);
             let e3 = await enclave.getE3(e3Id);
-            expect(e3.committeePublicKey).to.not.equal(ethers.keccak256(publicKey));
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            expect(e3.committeePublicKey).to.not.equal(publicKey);
+            await enclave.activate(e3Id, data);
             e3 = await enclave.getE3(e3Id);
             expect(e3.committeePublicKey).to.equal(publicKey);
         });
         it("returns true if E3 is activated successfully", async () => {
-            const { enclave, request } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             const e3Id = 0;
-            expect(await enclave.activate.staticCall(e3Id, ethers.ZeroHash)).to.be.equal(true);
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            expect(await enclave.activate.staticCall(e3Id, data)).to.be.equal(true);
         });
         it("emits E3Activated event", async () => {
-            const { enclave, request } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             const e3Id = 0;
-            await expect(enclave.activate(e3Id, ethers.ZeroHash)).to.emit(enclave, "E3Activated");
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await expect(enclave.activate(e3Id, data)).to.emit(enclave, "E3Activated");
         });
     });
     describe("publishInput()", function () {
@@ -690,138 +784,98 @@ describe("Enclave", function () {
                 .withArgs(0);
         });
         it("reverts if E3 has not been activated", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             const inputData = abiCoder.encode(["bytes32"], [ethers.ZeroHash]);
             await expect(enclave.getE3(0)).to.not.be.revert(ethers);
             await expect(enclave.publishInput(0, inputData))
                 .to.be.revertedWithCustomError(enclave, "E3NotActivated")
                 .withArgs(0);
-            await enclave.activate(0, ethers.ZeroHash);
         });
         it("reverts if input is not valid", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(0, ethers.ZeroHash);
+                customParams: request.customParams,
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, 0, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(0, data);
             await expect(enclave.publishInput(0, "0xaabbcc")).to.be.revertedWithCustomError(enclave, "InvalidInput");
         });
         it("reverts if outside of input window", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(0, ethers.ZeroHash);
+                customParams: request.customParams,
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, 0, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(0, data);
             await mine(2, { interval: request.duration });
             await expect(enclave.publishInput(0, ethers.ZeroHash)).to.be.revertedWithCustomError(enclave, "InputDeadlinePassed");
         });
         it("it allows publishing input to different requests", async function () {
             const fixtureSetup = () => setup();
-            const { enclave, request } = await loadFixture(fixtureSetup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(fixtureSetup);
             const inputData = "0x12345678";
-            await enclave.request({
-                filter: request.filter,
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(0, ethers.ZeroHash);
+                customParams: request.customParams,
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, 0, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(0, data);
             await enclave.publishInput(0, inputData);
-            // Make a new request, activate and call
-            await enclave.request({
-                filter: request.filter,
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(1, "0x0000000000000000000000000000000000000000000000000000000000000001");
+                customParams: request.customParams,
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, 1, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(1, data);
             await enclave.publishInput(1, inputData);
         });
         it("returns true if input is published successfully", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const inputData = "0x12345678";
-            await enclave.request({
-                filter: request.filter,
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(0, ethers.ZeroHash);
+                customParams: request.customParams,
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, 0, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(0, data);
             expect(await enclave.publishInput.staticCall(0, inputData)).to.equal(true);
         });
-        it("adds inputHash to merkle tree", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            const inputData = abiCoder.encode(["bytes"], ["0xaabbccddeeff"]);
-            // To create an instance of a LeanIMT, you must provide the hash function.
-            const tree = new LeanIMT(hash);
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
-                startWindow: request.startTime,
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            const e3Id = 0;
-            await enclave.activate(e3Id, ethers.ZeroHash);
-            tree.insert(hash(BigInt(ethers.keccak256(inputData)), BigInt(0)));
-            await enclave.publishInput(e3Id, inputData);
-            expect(await enclave.getInputRoot(e3Id)).to.equal(tree.root);
-            const secondInputData = abiCoder.encode(["bytes"], ["0x112233445566"]);
-            tree.insert(hash(BigInt(ethers.keccak256(secondInputData)), BigInt(1)));
-            await enclave.publishInput(e3Id, secondInputData);
-            expect(await enclave.getInputRoot(e3Id)).to.equal(tree.root);
-        });
-        it("emits InputPublished event", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
-                startWindow: request.startTime,
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            const e3Id = 0;
-            const inputData = abiCoder.encode(["bytes"], ["0xaabbccddeeff"]);
-            await enclave.activate(e3Id, ethers.ZeroHash);
-            const expectedHash = hash(BigInt(ethers.keccak256(inputData)), BigInt(0));
-            await expect(enclave.publishInput(e3Id, inputData))
-                .to.emit(enclave, "InputPublished")
-                .withArgs(e3Id, inputData, expectedHash, 0);
-        });
     });
     describe("publishCiphertextOutput()", function () {
         it("reverts if E3 does not exist", async function () {
@@ -831,54 +885,47 @@ describe("Enclave", function () {
                 .withArgs(0);
         });
         it("reverts if E3 has not been activated", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
-                startWindow: request.startTime,
+                startWindow: request.startWindow,
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+                customParams: request.customParams,
+            });
             await expect(enclave.publishCiphertextOutput(e3Id, "0x", "0x"))
                 .to.be.revertedWithCustomError(enclave, "E3NotActivated")
                 .withArgs(e3Id);
         });
         it("reverts if input deadline has not passed", async function () {
-            const { enclave, request } = await loadFixture(setup);
-            const tx = await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
-                startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            const block = await tx.getBlock();
-            const timestamp = block ? block.timestamp : await time.latest();
-            const expectedExpiration = timestamp + request.duration + 1;
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
+            const currentTime = await time.latest();
+            await makeRequest(enclave, usdcToken, {
+                ...request,
+                startWindow: [currentTime, currentTime + 100],
+            });
             const e3Id = 0;
-            await enclave.activate(e3Id, ethers.ZeroHash);
-            await expect(enclave.publishCiphertextOutput(e3Id, "0x", "0x"))
-                .to.be.revertedWithCustomError(enclave, "InputDeadlineNotPassed")
-                .withArgs(e3Id, expectedExpiration);
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
+            await expect(enclave.publishCiphertextOutput(e3Id, "0x", "0x")).to.be.revertedWithCustomError(enclave, "InputDeadlineNotPassed");
         });
         it("reverts if output has already been published", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+                customParams: request.customParams,
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             expect(await enclave.publishCiphertextOutput(e3Id, data, proof));
             await expect(enclave.publishCiphertextOutput(e3Id, data, proof))
@@ -886,68 +933,57 @@ describe("Enclave", function () {
                 .withArgs(e3Id);
         });
         it("reverts if output is not valid", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
+            await makeRequest(enclave, usdcToken, {
                 threshold: request.threshold,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
                 duration: request.duration,
                 e3Program: request.e3Program,
                 e3ProgramParams: request.e3ProgramParams,
                 computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+                customParams: request.customParams,
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             await expect(enclave.publishCiphertextOutput(e3Id, "0x", "0x")).to.be.revertedWithCustomError(enclave, "InvalidOutput");
         });
         it("sets ciphertextOutput correctly", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             expect(await enclave.publishCiphertextOutput(e3Id, data, proof));
             const e3 = await enclave.getE3(e3Id);
             expect(e3.ciphertextOutput).to.equal(dataHash);
         });
         it("returns true if output is published successfully", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             expect(await enclave.publishCiphertextOutput.staticCall(e3Id, data, proof)).to.equal(true);
         });
         it("emits CiphertextOutputPublished event", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             await expect(enclave.publishCiphertextOutput(e3Id, data, proof))
                 .to.emit(enclave, "CiphertextOutputPublished")
@@ -963,51 +999,38 @@ describe("Enclave", function () {
                 .withArgs(e3Id);
         });
         it("reverts if E3 has not been activated", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
+            });
             await expect(enclave.publishPlaintextOutput(e3Id, data, "0x"))
                 .to.be.revertedWithCustomError(enclave, "E3NotActivated")
                 .withArgs(e3Id);
         });
         it("reverts if ciphertextOutput has not been published", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await expect(enclave.publishPlaintextOutput(e3Id, data, "0x"))
                 .to.be.revertedWithCustomError(enclave, "CiphertextOutputNotPublished")
                 .withArgs(e3Id);
         });
         it("reverts if plaintextOutput has already been published", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             await enclave.publishCiphertextOutput(e3Id, data, proof);
             await enclave.publishPlaintextOutput(e3Id, data, proof);
@@ -1016,18 +1039,14 @@ describe("Enclave", function () {
                 .withArgs(e3Id);
         });
         it("reverts if output is not valid", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             await enclave.publishCiphertextOutput(e3Id, data, proof);
             await expect(enclave.publishPlaintextOutput(e3Id, data, "0x"))
@@ -1035,18 +1054,14 @@ describe("Enclave", function () {
                 .withArgs(data);
         });
         it("sets plaintextOutput correctly", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             await enclave.publishCiphertextOutput(e3Id, data, proof);
             expect(await enclave.publishPlaintextOutput(e3Id, data, proof));
@@ -1054,35 +1069,27 @@ describe("Enclave", function () {
             expect(e3.plaintextOutput).to.equal(data);
         });
         it("returns true if output is published successfully", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             await enclave.publishCiphertextOutput(e3Id, data, proof);
             expect(await enclave.publishPlaintextOutput.staticCall(e3Id, data, proof)).to.equal(true);
         });
         it("emits PlaintextOutputPublished event", async function () {
-            const { enclave, request } = await loadFixture(setup);
+            const { enclave, request, usdcToken, ciphernodeRegistryContract, operator1, operator2, } = await loadFixture(setup);
             const e3Id = 0;
-            await enclave.request({
-                filter: request.filter,
-                threshold: request.threshold,
+            await makeRequest(enclave, usdcToken, {
+                ...request,
                 startWindow: [await time.latest(), (await time.latest()) + 100],
-                duration: request.duration,
-                e3Program: request.e3Program,
-                e3ProgramParams: request.e3ProgramParams,
-                computeProviderParams: request.computeProviderParams,
-            }, { value: 10 });
-            await enclave.activate(e3Id, ethers.ZeroHash);
+            });
+            await setupAndPublishCommittee(ciphernodeRegistryContract, e3Id, [await operator1.getAddress(), await operator2.getAddress()], data, operator1, operator2);
+            await enclave.activate(e3Id, data);
             await mine(2, { interval: request.duration });
             await enclave.publishCiphertextOutput(e3Id, data, proof);
             await expect(await enclave.publishPlaintextOutput(e3Id, data, proof))