[FEAT] Add CommitmentRegistry deploy script and local network config (#62)

* [FEAT] Add CommitmentRegistry deploy script and local network config

* [FEAT] Use hardhat-upgrades for proxy deploy, add pagination tests

Author: roeezolantz

contracts/internal/registry-chain/.env.example

@@ -0,0 +1,3 @@
+# DO NOT USE IN PRODUCTION
+# Same deployer key as host-chain (address: 0x4e6206fC78674E5eFf48Dcd0166060f95a832c60)
+KEY=0xb03608c1c1f1461ed55c1c2315ab27fe82e2fe4c289ff753dea99078848d27dd

contracts/internal/registry-chain/contracts/ERC1967Proxy.sol

@@ -19,6 +19,14 @@ const config: HardhatUserConfig = {
   defaultNetwork: "hardhat",
   networks: {
     hardhat: { allowUnlimitedContractSize: true },
+    localfhenix: {
+      url: "http://127.0.0.1:42069",
+      accounts: process.env.KEY ? [process.env.KEY] : [],
+    },
+    localfhenixk8s: {
+      url: "http://hostchain:8547",
+      accounts: process.env.KEY ? [process.env.KEY] : [],
+    },
     arbitrumSepolia: {
       chainId: 421614,
       url: "https://little-convincing-fog.arbitrum-sepolia.quiknode.pro/e925be62bdfa8faab560daa332c0c95e26189870/",

contracts/internal/registry-chain/hardhat.config.ts

@@ -6,6 +6,7 @@
     "test": "hardhat test --network hardhat",
     "test:gas": "REPORT_GAS=true hardhat test --network hardhat",
     "compile": "hardhat compile",
+    "task:deploy": "hardhat run scripts/deploy.ts",
     "clean": "rimraf ./artifacts ./cache ./types ./.openzeppelin/*"
   },
   "author": "Fhenix",

contracts/internal/registry-chain/package.json

@@ -0,0 +1,38 @@
+import hre from "hardhat";
+import { deployUUPSProxy } from "../utils/deploy";
+
+// OZ Relayer signer address (deterministic from dev keystore)
+const DEFAULT_POSTER_ADDRESS = "0x3f1Eae7D46d88F08fc2F8ed27FCb2AB183EB2d0E";
+const OZ_RELAYER_ADDRESS = process.env.POSTER_ADDRESS || DEFAULT_POSTER_ADDRESS;
+
+// Commitment version to activate (must match COMMITMENT_VERSION in fhe-engine)
+const INITIAL_VERSION = "0x0000000000000000000000000000000000000000000000000000000000000001";
+
+async function main() {
+  const [deployer] = await hre.ethers.getSigners();
+  if (!process.env.POSTER_ADDRESS) {
+    console.warn(`WARNING: POSTER_ADDRESS not set, using default dev address: ${DEFAULT_POSTER_ADDRESS}`);
+  }
+  console.log("Deploying CommitmentRegistry with account:", deployer.address);
+
+  const { proxy: registry, address: proxyAddress } = await deployUUPSProxy(
+    "CommitmentRegistry",
+    [deployer.address, OZ_RELAYER_ADDRESS],
+  );
+
+  console.log("Owner:", deployer.address);
+  console.log("Poster:", OZ_RELAYER_ADDRESS);
+
+  // Activate initial version
+  const tx = await registry.setVersionStatus(INITIAL_VERSION, 1); // 1 = Active
+  await tx.wait();
+  console.log("Version", INITIAL_VERSION, "activated");
+
+  // Output the address in a parseable format for the deploy script
+  console.log(`COMMITMENT_REGISTRY_ADDRESS=${proxyAddress}`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

contracts/internal/registry-chain/scripts/deploy.ts

@@ -1,6 +1,7 @@
 import { expect } from "chai";
 import hre from "hardhat";
 const { ethers } = hre;
+import { upgrades } from "hardhat";
 
 function randomBytes32(): string {
   return ethers.hexlify(ethers.randomBytes(32));
@@ -50,29 +51,23 @@ export function shouldBehaveLikeCommitmentRegistry(): void {
 
     it("should revert when initializing with zero owner", async function () {
       const CommitmentRegistry = await ethers.getContractFactory("CommitmentRegistry");
-      const impl = await CommitmentRegistry.deploy();
-      await impl.waitForDeployment();
-      const ERC1967Proxy = await ethers.getContractFactory("ERC1967Proxy");
-      const initData = CommitmentRegistry.interface.encodeFunctionData("initialize", [
-        ethers.ZeroAddress,
-        this.poster.address,
-      ]);
       await expect(
-        ERC1967Proxy.deploy(await impl.getAddress(), initData)
+        upgrades.deployProxy(
+          CommitmentRegistry,
+          [ethers.ZeroAddress, this.poster.address],
+          { kind: "uups", initializer: "initialize" },
+        )
       ).to.be.reverted;
     });
 
     it("should revert when initializing with zero poster", async function () {
       const CommitmentRegistry = await ethers.getContractFactory("CommitmentRegistry");
-      const impl = await CommitmentRegistry.deploy();
-      await impl.waitForDeployment();
-      const ERC1967Proxy = await ethers.getContractFactory("ERC1967Proxy");
-      const initData = CommitmentRegistry.interface.encodeFunctionData("initialize", [
-        this.owner.address,
-        ethers.ZeroAddress,
-      ]);
       await expect(
-        ERC1967Proxy.deploy(await impl.getAddress(), initData)
+        upgrades.deployProxy(
+          CommitmentRegistry,
+          [this.owner.address, ethers.ZeroAddress],
+          { kind: "uups", initializer: "initialize" },
+        )
       ).to.be.reverted;
     });
   });
@@ -593,6 +588,70 @@ export function shouldBehaveLikeCommitmentRegistry(): void {
       expect(await this.registry.getSize(VERSION_1)).to.equal(1);
     });
 
+    it("should return handles with getHandles pagination", async function () {
+      await this.registry.setVersionStatus(VERSION_1, VersionStatus.Active);
+      const handles = Array.from({ length: 10 }, () => randomBytes32());
+      const commitHashes = Array.from({ length: 10 }, () => randomBytes32());
+      const registryAsPoster = this.registry.connect(this.poster);
+      await registryAsPoster.postCommitments(VERSION_1, handles, commitHashes);
+
+      // First page
+      const page1 = await this.registry.getHandles(VERSION_1, 0, 5);
+      expect(page1.length).to.equal(5);
+      for (let i = 0; i < 5; i++) {
+        expect(page1[i]).to.equal(handles[i]);
+      }
+
+      // Second page
+      const page2 = await this.registry.getHandles(VERSION_1, 5, 5);
+      expect(page2.length).to.equal(5);
+      for (let i = 0; i < 5; i++) {
+        expect(page2[i]).to.equal(handles[5 + i]);
+      }
+    });
+
+    it("should return empty array when offset exceeds total", async function () {
+      await this.registry.setVersionStatus(VERSION_1, VersionStatus.Active);
+      const registryAsPoster = this.registry.connect(this.poster);
+      await registryAsPoster.postCommitments(VERSION_1, [randomBytes32()], [randomBytes32()]);
+
+      const result = await this.registry.getHandles(VERSION_1, 100, 10);
+      expect(result.length).to.equal(0);
+    });
+
+    it("should clamp limit when it exceeds remaining items", async function () {
+      await this.registry.setVersionStatus(VERSION_1, VersionStatus.Active);
+      const handles = Array.from({ length: 3 }, () => randomBytes32());
+      const commitHashes = Array.from({ length: 3 }, () => randomBytes32());
+      const registryAsPoster = this.registry.connect(this.poster);
+      await registryAsPoster.postCommitments(VERSION_1, handles, commitHashes);
+
+      const result = await this.registry.getHandles(VERSION_1, 1, 100);
+      expect(result.length).to.equal(2);
+      expect(result[0]).to.equal(handles[1]);
+      expect(result[1]).to.equal(handles[2]);
+    });
+
+    it("should return handle by index", async function () {
+      await this.registry.setVersionStatus(VERSION_1, VersionStatus.Active);
+      const handles = Array.from({ length: 5 }, () => randomBytes32());
+      const commitHashes = Array.from({ length: 5 }, () => randomBytes32());
+      const registryAsPoster = this.registry.connect(this.poster);
+      await registryAsPoster.postCommitments(VERSION_1, handles, commitHashes);
+
+      for (let i = 0; i < 5; i++) {
+        expect(await this.registry.getHandleByIndex(VERSION_1, i)).to.equal(handles[i]);
+      }
+    });
+
+    it("should revert when getHandleByIndex is out of bounds", async function () {
+      await this.registry.setVersionStatus(VERSION_1, VersionStatus.Active);
+      const registryAsPoster = this.registry.connect(this.poster);
+      await registryAsPoster.postCommitments(VERSION_1, [randomBytes32()], [randomBytes32()]);
+
+      await expect(this.registry.getHandleByIndex(VERSION_1, 1)).to.be.reverted;
+    });
+
     it("should still return commitments after version is Revoked", async function () {
       await this.registry.setVersionStatus(VERSION_1, VersionStatus.Active);
       const handle = randomBytes32();

contracts/internal/registry-chain/test/commitmentRegistry/CommitmentRegistry.behavior.ts

@@ -1,5 +1,6 @@
 import hre from "hardhat";
 const { ethers } = hre;
+import { upgrades } from "hardhat";
 import { BaseContract } from "ethers";
 
 export interface CommitmentRegistryFixture {
@@ -13,18 +14,12 @@ export async function deployCommitmentRegistryFixture(): Promise<CommitmentRegis
   const [owner, poster, otherAccount] = await ethers.getSigners();
 
   const CommitmentRegistry = await ethers.getContractFactory("CommitmentRegistry");
-  const impl = await CommitmentRegistry.deploy();
-  await impl.waitForDeployment();
-
-  const ERC1967Proxy = await ethers.getContractFactory("ERC1967Proxy");
-  const initData = CommitmentRegistry.interface.encodeFunctionData("initialize", [
-    owner.address,
-    poster.address,
-  ]);
-  const proxy = await ERC1967Proxy.deploy(await impl.getAddress(), initData);
-  await proxy.waitForDeployment();
-
-  const registry = CommitmentRegistry.attach(await proxy.getAddress());
+  const deployed = await upgrades.deployProxy(
+    CommitmentRegistry,
+    [owner.address, poster.address],
+    { kind: "uups", initializer: "initialize" },
+  );
+  const registry = await deployed.waitForDeployment();
 
   return { registry, owner, poster, otherAccount };
 }

contracts/internal/registry-chain/test/commitmentRegistry/CommitmentRegistry.fixture.ts

@@ -0,0 +1,23 @@
+import { ethers, upgrades } from "hardhat";
+import { Contract } from "ethers";
+
+/**
+ * Deploys a UUPS proxy for the given contract.
+ * @param contractName The contract to deploy behind a proxy
+ * @param initArgs Arguments passed to the initialize function
+ * @returns The proxy contract instance and its address
+ */
+export async function deployUUPSProxy(
+  contractName: string,
+  initArgs: unknown[],
+): Promise<{ proxy: Contract; address: string }> {
+  const factory = await ethers.getContractFactory(contractName);
+  const deployed = await upgrades.deployProxy(factory, initArgs, {
+    kind: "uups",
+    initializer: "initialize",
+  });
+  const proxy = (await deployed.waitForDeployment()) as unknown as Contract;
+  const address = await proxy.getAddress();
+  console.log(`Deployed ${contractName} proxy to: ${address}`);
+  return { proxy, address };
+}