@enclave-e3/contracts 0.1.4 → 0.1.6

package/contracts/test/MockRegistryFilter.sol

@@ -1,117 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-only
-//
-// This file is provided WITHOUT ANY WARRANTY;
-// without even the implied warranty of MERCHANTABILITY
-// or FITNESS FOR A PARTICULAR PURPOSE.
-pragma solidity >=0.8.27;
-
-import { IRegistryFilter } from "../interfaces/IRegistryFilter.sol";
-import {
-    OwnableUpgradeable
-} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-
-interface IRegistry {
-    function publishCommittee(
-        uint256 e3Id,
-        address[] calldata ciphernodes,
-        bytes calldata publicKey
-    ) external;
-}
-
-contract MockNaiveRegistryFilter is IRegistryFilter, OwnableUpgradeable {
-    struct Committee {
-        address[] nodes;
-        uint32[2] threshold;
-        bytes publicKey;
-    }
-
-    ////////////////////////////////////////////////////////////
-    //                                                        //
-    //                 Storage Variables                      //
-    //                                                        //
-    ////////////////////////////////////////////////////////////
-
-    address public registry;
-
-    mapping(uint256 e3 => Committee committee) public committees;
-
-    ////////////////////////////////////////////////////////////
-    //                                                        //
-    //                        Errors                          //
-    //                                                        //
-    ////////////////////////////////////////////////////////////
-
-    error CommitteeAlreadyExists();
-    error CommitteeAlreadyPublished();
-    error CommitteeDoesNotExist();
-    error CommitteeNotPublished();
-    error OnlyRegistry();
-
-    ////////////////////////////////////////////////////////////
-    //                                                        //
-    //                     Modifiers                          //
-    //                                                        //
-    ////////////////////////////////////////////////////////////
-
-    modifier onlyRegistry() {
-        require(msg.sender == registry, OnlyRegistry());
-        _;
-    }
-
-    ////////////////////////////////////////////////////////////
-    //                                                        //
-    //                   Initialization                       //
-    //                                                        //
-    ////////////////////////////////////////////////////////////
-
-    constructor(address _owner, address _enclave) {
-        initialize(_owner, _enclave);
-    }
-
-    function initialize(address _owner, address _registry) public initializer {
-        __Ownable_init(msg.sender);
-        setRegistry(_registry);
-        if (_owner != owner()) transferOwnership(_owner);
-    }
-
-    ////////////////////////////////////////////////////////////
-    //                                                        //
-    //                  Core Entrypoints                      //
-    //                                                        //
-    ////////////////////////////////////////////////////////////
-
-    function requestCommittee(
-        uint256 e3Id,
-        uint32[2] calldata threshold
-    ) external onlyRegistry returns (bool success) {
-        Committee storage committee = committees[e3Id];
-        require(committee.threshold.length == 0, CommitteeAlreadyExists());
-        committee.threshold = threshold;
-        success = true;
-    }
-
-    function publishCommittee(
-        uint256 e3Id,
-        address[] memory nodes,
-        bytes memory publicKey
-    ) external onlyOwner {
-        Committee storage committee = committees[e3Id];
-        require(
-            keccak256(committee.publicKey) == keccak256(hex""),
-            CommitteeAlreadyPublished()
-        );
-        committee.nodes = nodes;
-        committee.publicKey = publicKey;
-        IRegistry(registry).publishCommittee(e3Id, nodes, publicKey);
-    }
-
-    ////////////////////////////////////////////////////////////
-    //                                                        //
-    //                   Set Functions                        //
-    //                                                        //
-    ////////////////////////////////////////////////////////////
-
-    function setRegistry(address _registry) public onlyOwner {
-        registry = _registry;
-    }
-}

package/dist/ignition/modules/mockInputValidator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mockInputValidator.d.ts","sourceRoot":"","sources":["../../../ignition/modules/mockInputValidator.ts"],"names":[],"mappings":"wBAaM,GAAG;AAJT,wBAIU"}

package/dist/ignition/modules/naiveRegistryFilter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"naiveRegistryFilter.d.ts","sourceRoot":"","sources":["../../../ignition/modules/naiveRegistryFilter.ts"],"names":[],"mappings":"wBAmBM,GAAG;AAVT,wBAUU"}

package/dist/ignition/modules/naiveRegistryFilter.js

@@ -1,16 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-only
-//
-// This file is provided WITHOUT ANY WARRANTY;
-// without even the implied warranty of MERCHANTABILITY
-// or FITNESS FOR A PARTICULAR PURPOSE.
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
-export default buildModule("NaiveRegistryFilter", (m) => {
-    const ciphernodeRegistryAddress = m.getParameter("ciphernodeRegistryAddress");
-    const owner = m.getParameter("owner");
-    const naiveRegistryFilter = m.contract("NaiveRegistryFilter", [
-        owner,
-        ciphernodeRegistryAddress,
-    ]);
-    return { naiveRegistryFilter };
-});

package/dist/scripts/deployAndSave/mockInputValidator.d.ts

@@ -1,6 +0,0 @@
-import type { HardhatRuntimeEnvironment } from "hardhat/types/hre";
-import { MockInputValidator } from "../../types";
-export declare const deployAndSaveMockInputValidator: (hre: HardhatRuntimeEnvironment) => Promise<{
-    inputValidator: MockInputValidator;
-}>;
-//# sourceMappingURL=mockInputValidator.d.ts.map

package/dist/scripts/deployAndSave/mockInputValidator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mockInputValidator.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/mockInputValidator.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAGnE,OAAO,EACL,kBAAkB,EAEnB,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,+BAA+B,GAC1C,KAAK,yBAAyB,KAC7B,OAAO,CAAC;IACT,cAAc,EAAE,kBAAkB,CAAC;CACpC,CA0BA,CAAC"}

package/dist/scripts/deployAndSave/mockInputValidator.js

@@ -1,18 +0,0 @@
-import MockInputValidatorModule from "../../ignition/modules/mockInputValidator";
-import { MockInputValidator__factory as MockInputValidatorFactory, } from "../../types";
-import { storeDeploymentArgs } from "../utils";
-export const deployAndSaveMockInputValidator = async (hre) => {
-    const { ignition, ethers } = await hre.network.connect();
-    const [signer] = await ethers.getSigners();
-    const inputValidator = await ignition.deploy(MockInputValidatorModule);
-    await inputValidator.mockInputValidator.waitForDeployment();
-    const inputValidatorAddress = await inputValidator.mockInputValidator.getAddress();
-    const chain = hre.globalOptions.network;
-    const blockNumber = await ethers.provider.getBlockNumber();
-    storeDeploymentArgs({
-        blockNumber,
-        address: inputValidatorAddress,
-    }, "MockInputValidator", chain);
-    const inputValidatorContract = MockInputValidatorFactory.connect(inputValidatorAddress, signer);
-    return { inputValidator: inputValidatorContract };
-};

package/dist/scripts/deployAndSave/naiveRegistryFilter.d.ts

@@ -1,11 +0,0 @@
-import type { HardhatRuntimeEnvironment } from "hardhat/types/hre";
-import { NaiveRegistryFilter } from "../../types";
-export interface NaiveRegistryFilterArgs {
-    ciphernodeRegistryAddress?: string;
-    owner?: string;
-    hre: HardhatRuntimeEnvironment;
-}
-export declare const deployAndSaveNaiveRegistryFilter: ({ ciphernodeRegistryAddress, owner, hre, }: NaiveRegistryFilterArgs) => Promise<{
-    naiveRegistryFilter: NaiveRegistryFilter;
-}>;
-//# sourceMappingURL=naiveRegistryFilter.d.ts.map

package/dist/scripts/deployAndSave/naiveRegistryFilter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"naiveRegistryFilter.d.ts","sourceRoot":"","sources":["../../../scripts/deployAndSave/naiveRegistryFilter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAGnE,OAAO,EACL,mBAAmB,EAEpB,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,uBAAuB;IACtC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,yBAAyB,CAAC;CAChC;AAED,eAAO,MAAM,gCAAgC,GAAU,4CAIpD,uBAAuB,KAAG,OAAO,CAAC;IACnC,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CA4DA,CAAC"}

package/dist/scripts/deployAndSave/naiveRegistryFilter.js

@@ -1,41 +0,0 @@
-import NaiveRegistryFilterModule from "../../ignition/modules/naiveRegistryFilter";
-import { NaiveRegistryFilter__factory as NaiveRegistryFilterFactory, } from "../../types";
-import { readDeploymentArgs, storeDeploymentArgs } from "../utils";
-export const deployAndSaveNaiveRegistryFilter = async ({ ciphernodeRegistryAddress, owner, hre, }) => {
-    const { ignition, ethers } = await hre.network.connect();
-    const [signer] = await ethers.getSigners();
-    const chain = hre.globalOptions.network;
-    const preDeployedArgs = readDeploymentArgs("NaiveRegistryFilter", chain);
-    if (!ciphernodeRegistryAddress ||
-        !owner ||
-        (preDeployedArgs?.constructorArgs?.ciphernodeRegistryAddress ===
-            ciphernodeRegistryAddress &&
-            preDeployedArgs?.constructorArgs?.owner === owner)) {
-        if (!preDeployedArgs?.address) {
-            throw new Error("NaiveRegistryFilter address not found, it must be deployed first");
-        }
-        const naiveRegistryFilterContract = NaiveRegistryFilterFactory.connect(preDeployedArgs.address, signer);
-        return { naiveRegistryFilter: naiveRegistryFilterContract };
-    }
-    const naiveRegistryFilter = await ignition.deploy(NaiveRegistryFilterModule, {
-        parameters: {
-            NaiveRegistryFilter: {
-                ciphernodeRegistryAddress,
-                owner,
-            },
-        },
-    });
-    await naiveRegistryFilter.naiveRegistryFilter.waitForDeployment();
-    const naiveRegistryFilterAddress = await naiveRegistryFilter.naiveRegistryFilter.getAddress();
-    const blockNumber = await ethers.provider.getBlockNumber();
-    storeDeploymentArgs({
-        constructorArgs: {
-            ciphernodeRegistryAddress: ciphernodeRegistryAddress,
-            owner,
-        },
-        blockNumber,
-        address: naiveRegistryFilterAddress,
-    }, "NaiveRegistryFilter", chain);
-    const naiveRegistryFilterContract = NaiveRegistryFilterFactory.connect(naiveRegistryFilterAddress, signer);
-    return { naiveRegistryFilter: naiveRegistryFilterContract };
-};

package/dist/test/CiphernodeRegistry/CiphernodeRegistryOwnable.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CiphernodeRegistryOwnable.spec.d.ts","sourceRoot":"","sources":["../../../test/CiphernodeRegistry/CiphernodeRegistryOwnable.spec.ts"],"names":[],"mappings":""}

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

@@ -1,279 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-only
-//
-// This file is provided WITHOUT ANY WARRANTY;
-// without even the implied warranty of MERCHANTABILITY
-// or FITNESS FOR A PARTICULAR PURPOSE.
-import { LeanIMT } from "@zk-kit/lean-imt";
-import { expect } from "chai";
-import { network } from "hardhat";
-import { poseidon2 } from "poseidon-lite";
-import CiphernodeRegistryModule from "../../ignition/modules/ciphernodeRegistry";
-import NaiveRegistryFilterModule from "../../ignition/modules/naiveRegistryFilter";
-import { CiphernodeRegistryOwnable__factory as CiphernodeRegistryFactory, NaiveRegistryFilter__factory as NaiveRegistryFilterFactory, } from "../../types";
-const AddressOne = "0x0000000000000000000000000000000000000001";
-const AddressTwo = "0x0000000000000000000000000000000000000002";
-const AddressThree = "0x0000000000000000000000000000000000000003";
-const { ethers, networkHelpers, ignition } = await network.connect();
-const { loadFixture } = networkHelpers;
-const data = "0xda7a";
-const dataHash = ethers.keccak256(data);
-// Hash function used to compute the tree nodes.
-const hash = (a, b) => poseidon2([a, b]);
-describe("CiphernodeRegistryOwnable", function () {
-    async function setup() {
-        const [owner, notTheOwner] = await ethers.getSigners();
-        const registryContract = await ignition.deploy(CiphernodeRegistryModule, {
-            parameters: {
-                CiphernodeRegistry: {
-                    enclaveAddress: await owner.getAddress(),
-                    owner: await owner.getAddress(),
-                },
-            },
-        });
-        const filterContract = await ignition.deploy(NaiveRegistryFilterModule, {
-            parameters: {
-                NaiveRegistryFilter: {
-                    owner: await owner.getAddress(),
-                    ciphernodeRegistryAddress: await registryContract.cipherNodeRegistry.getAddress(),
-                },
-            },
-        });
-        const registry = CiphernodeRegistryFactory.connect(await registryContract.cipherNodeRegistry.getAddress(), owner);
-        const filter = NaiveRegistryFilterFactory.connect(await filterContract.naiveRegistryFilter.getAddress(), owner);
-        const tree = new LeanIMT(hash);
-        await registry.addCiphernode(AddressOne);
-        tree.insert(BigInt(AddressOne));
-        await registry.addCiphernode(AddressTwo);
-        tree.insert(BigInt(AddressTwo));
-        return {
-            owner,
-            notTheOwner,
-            registry,
-            filter,
-            tree,
-            request: {
-                e3Id: 1,
-                filter: await filter.getAddress(),
-                threshold: [2, 2],
-            },
-        };
-    }
-    describe("constructor / initialize()", function () {
-        it("correctly sets `_owner` and `enclave` ", async function () {
-            const poseidonFactory = await ethers.getContractFactory("PoseidonT3");
-            const poseidonDeployment = await poseidonFactory.deploy();
-            const [deployer] = await ethers.getSigners();
-            if (!deployer)
-                throw new Error("Bad getSigners() output");
-            const ciphernodeRegistryFactory = await ethers.getContractFactory("CiphernodeRegistryOwnable", {
-                libraries: {
-                    PoseidonT3: await poseidonDeployment.getAddress(),
-                },
-            });
-            const ciphernodeRegistry = await ciphernodeRegistryFactory.deploy(deployer.address, AddressTwo);
-            expect(await ciphernodeRegistry.owner()).to.equal(deployer.address);
-            expect(await ciphernodeRegistry.enclave()).to.equal(AddressTwo);
-        });
-    });
-    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, request.filter, request.threshold);
-            await expect(registry.requestCommittee(request.e3Id, request.filter, request.threshold)).to.be.revertedWithCustomError(registry, "CommitteeAlreadyRequested");
-        });
-        it("stores the registry filter for the given e3Id", async function () {
-            const { registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, request.filter, request.threshold);
-            expect(await registry.getFilter(request.e3Id)).to.equal(request.filter);
-        });
-        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, request.filter, request.threshold);
-            expect(await registry.rootAt(request.e3Id)).to.equal(await registry.root());
-        });
-        it("requests a committee from the given filter", async function () {
-            const { registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, request.filter, request.threshold);
-            expect(await registry.getFilter(request.e3Id)).to.equal(request.filter);
-        });
-        it("emits a CommitteeRequested event", async function () {
-            const { registry, request } = await loadFixture(setup);
-            await expect(registry.requestCommittee(request.e3Id, request.filter, request.threshold))
-                .to.emit(registry, "CommitteeRequested")
-                .withArgs(request.e3Id, request.filter, request.threshold);
-        });
-        it("reverts if filter.requestCommittee() fails", async function () {
-            const { owner, registry, filter, request } = await loadFixture(setup);
-            await filter.setRegistry(await owner.getAddress());
-            await filter.requestCommittee(request.e3Id, request.threshold);
-            await filter.setRegistry(await registry.getAddress());
-            await expect(registry.requestCommittee(request.e3Id, request.filter, request.threshold)).to.be.revertedWithCustomError(filter, "CommitteeAlreadyExists");
-        });
-        it("returns true if the request is successful", async function () {
-            const { registry, request } = await loadFixture(setup);
-            expect(await registry.requestCommittee.staticCall(request.e3Id, request.filter, request.threshold)).to.be.true;
-        });
-    });
-    describe("publishCommittee()", function () {
-        it("reverts if the caller is not the filter for the given e3Id", async function () {
-            const { registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, request.filter, request.threshold);
-            await expect(registry.publishCommittee(request.e3Id, "0xc0de", data)).to.be.revertedWithCustomError(registry, "OnlyFilter");
-        });
-        it("stores the public key of the committee", async function () {
-            const { filter, registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, request.filter, request.threshold);
-            await filter.publishCommittee(request.e3Id, [AddressOne, AddressTwo], data);
-            expect(await registry.committeePublicKey(request.e3Id)).to.equal(dataHash);
-        });
-        it("emits a CommitteePublished event", async function () {
-            const { filter, registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, request.filter, request.threshold);
-            await expect(await filter.publishCommittee(request.e3Id, [AddressOne, AddressTwo], data))
-                .to.emit(registry, "CommitteePublished")
-                .withArgs(request.e3Id, data);
-        });
-    });
-    describe("addCiphernode()", function () {
-        it("reverts if the caller is not the owner", async function () {
-            const { registry, notTheOwner } = await loadFixture(setup);
-            await expect(registry.connect(notTheOwner).addCiphernode(AddressThree))
-                .to.be.revertedWithCustomError(registry, "OwnableUnauthorizedAccount")
-                .withArgs(await notTheOwner.getAddress());
-        });
-        it("adds the ciphernode to the registry", async function () {
-            const { registry } = await loadFixture(setup);
-            expect(await registry.addCiphernode(AddressThree));
-            expect(await registry.isCiphernodeEligible(AddressThree)).to.be.true;
-        });
-        it("increments numCiphernodes", async function () {
-            const { registry } = await loadFixture(setup);
-            const numCiphernodes = await registry.numCiphernodes();
-            expect(await registry.addCiphernode(AddressThree));
-            expect(await registry.numCiphernodes()).to.equal(numCiphernodes + BigInt(1));
-        });
-        it("emits a CiphernodeAdded event", async function () {
-            const { registry } = await loadFixture(setup);
-            const treeSize = await registry.treeSize();
-            const numCiphernodes = await registry.numCiphernodes();
-            await expect(await registry.addCiphernode(AddressThree))
-                .to.emit(registry, "CiphernodeAdded")
-                .withArgs(AddressThree, treeSize, numCiphernodes + BigInt(1), treeSize + BigInt(1));
-        });
-    });
-    describe("removeCiphernode()", function () {
-        it("reverts if the caller is not the owner", async function () {
-            const { registry, notTheOwner } = await loadFixture(setup);
-            await expect(registry.connect(notTheOwner).removeCiphernode(AddressOne, []))
-                .to.be.revertedWithCustomError(registry, "OwnableUnauthorizedAccount")
-                .withArgs(await notTheOwner.getAddress());
-        });
-        it("removes the ciphernode from the registry", async function () {
-            const { registry } = await loadFixture(setup);
-            const tree = new LeanIMT(hash);
-            tree.insert(BigInt(AddressOne));
-            tree.insert(BigInt(AddressTwo));
-            const index = tree.indexOf(BigInt(AddressOne));
-            const proof = tree.generateProof(index);
-            tree.update(index, BigInt(0));
-            expect(await registry.isEnabled(AddressOne)).to.be.true;
-            expect(await registry.removeCiphernode(AddressOne, proof.siblings));
-            expect(await registry.isEnabled(AddressOne)).to.be.false;
-            expect(await registry.root()).to.equal(tree.root);
-        });
-        it("decrements numCiphernodes", async function () {
-            const { registry, tree } = await loadFixture(setup);
-            const numCiphernodes = await registry.numCiphernodes();
-            const index = tree.indexOf(BigInt(AddressOne));
-            const proof = tree.generateProof(index);
-            expect(await registry.removeCiphernode(AddressOne, proof.siblings));
-            expect(await registry.numCiphernodes()).to.equal(numCiphernodes - BigInt(1));
-        });
-        it("emits a CiphernodeRemoved event", async function () {
-            const { registry, tree } = await loadFixture(setup);
-            const numCiphernodes = await registry.numCiphernodes();
-            const size = await registry.treeSize();
-            const index = tree.indexOf(BigInt(AddressOne));
-            const proof = tree.generateProof(index);
-            await expect(registry.removeCiphernode(AddressOne, proof.siblings))
-                .to.emit(registry, "CiphernodeRemoved")
-                .withArgs(AddressOne, index, numCiphernodes - BigInt(1), size);
-        });
-    });
-    describe("setEnclave()", function () {
-        it("reverts if the caller is not the owner", async function () {
-            const { registry, notTheOwner } = await loadFixture(setup);
-            await expect(registry.connect(notTheOwner).setEnclave(AddressThree)).to.be.revertedWithCustomError(registry, "OwnableUnauthorizedAccount");
-        });
-        it("sets the enclave address", async function () {
-            const { registry } = await loadFixture(setup);
-            expect(await registry.setEnclave(AddressThree));
-            expect(await registry.enclave()).to.equal(AddressThree);
-        });
-        it("emits an EnclaveSet event", async function () {
-            const { registry } = await loadFixture(setup);
-            await expect(await registry.setEnclave(AddressThree))
-                .to.emit(registry, "EnclaveSet")
-                .withArgs(AddressThree);
-        });
-    });
-    describe("committeePublicKey()", function () {
-        it("returns the public key of the committee for the given e3Id", async function () {
-            const { filter, registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, request.filter, request.threshold);
-            await filter.publishCommittee(request.e3Id, [AddressOne, AddressTwo], data);
-            expect(await registry.committeePublicKey(request.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, request.filter, request.threshold);
-            await expect(registry.committeePublicKey(request.e3Id)).to.be.revertedWithCustomError(registry, "CommitteeNotPublished");
-        });
-    });
-    describe("isCiphernodeEligible()", function () {
-        it("returns true if the ciphernode is in the registry", async function () {
-            const { registry } = await loadFixture(setup);
-            expect(await registry.isCiphernodeEligible(AddressOne)).to.be.true;
-        });
-        it("returns false if the ciphernode is not in the registry", async function () {
-            const { registry } = await loadFixture(setup);
-            expect(await registry.isCiphernodeEligible(AddressThree)).to.be.false;
-        });
-    });
-    describe("isEnabled()", function () {
-        it("returns true if the ciphernode is currently enabled", async function () {
-            const { registry } = await loadFixture(setup);
-            expect(await registry.isEnabled(AddressOne)).to.be.true;
-        });
-        it("returns false if the ciphernode is not currently enabled", async function () {
-            const { registry } = await loadFixture(setup);
-            expect(await registry.isEnabled(AddressThree)).to.be.false;
-        });
-    });
-    describe("root()", function () {
-        it("returns the root of the ciphernode registry merkle tree", async function () {
-            const { registry, tree } = await loadFixture(setup);
-            expect(await registry.root()).to.equal(tree.root);
-        });
-    });
-    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, request.filter, request.threshold);
-            expect(await registry.rootAt(request.e3Id)).to.equal(tree.root);
-        });
-    });
-    describe("getFilter()", function () {
-        it("returns the registry filter for the given e3Id", async function () {
-            const { registry, request } = await loadFixture(setup);
-            await registry.requestCommittee(request.e3Id, request.filter, request.threshold);
-            expect(await registry.getFilter(request.e3Id)).to.equal(request.filter);
-        });
-    });
-    describe("treeSize()", function () {
-        it("returns the size of the ciphernode registry merkle tree", async function () {
-            const { registry, tree } = await loadFixture(setup);
-            expect(await registry.treeSize()).to.equal(tree.size);
-        });
-    });
-});

package/dist/test/CiphernodeRegistry/NaiveRegistryFilter.spec.d.ts

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

package/dist/test/CiphernodeRegistry/NaiveRegistryFilter.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NaiveRegistryFilter.spec.d.ts","sourceRoot":"","sources":["../../../test/CiphernodeRegistry/NaiveRegistryFilter.spec.ts"],"names":[],"mappings":""}