add chainRootHash to ts code and tests

Whytecrowe · Whytecrowe · commit 33976c408e48 · 2024-09-26T12:58:53.000-07:00
diff --git a/src/deploy/campaign/environments.ts b/src/deploy/campaign/environments.ts
@@ -60,12 +60,14 @@ export const getConfig = async ({
   admins,
   zeroVaultAddress,
   env, // this is ONLY used for tests!
+  chainRootHash, // this is ONLY used for tests! should be read from the env variable in prod
 } : {
   deployer : SignerWithAddress;
   governors ?: Array<string>;
   admins ?: Array<string>;
   zeroVaultAddress ?: string;
   env ?: string;
+  chainRootHash ?: string;
 }) : Promise<IZNSCampaignConfig<SignerWithAddress>> => {
   // Will throw an error based on any invalid setup, given the `ENV_LEVEL` set
   const priceConfig = validateEnv(env);
@@ -102,11 +104,20 @@ export const getConfig = async ({
   // Get admin addresses set through env, if any
   const adminAddresses = getCustomAddresses("ADMIN_ADDRESSES", deployerAddress, admins);
 
+  let chainRootHashFinal;
+  if (process.env.ENV_LEVEL === "dev") {
+    chainRootHashFinal = chainRootHash || ethers.ZeroHash;
+  } else {
+    requires(!!process.env.CHAIN_ROOT_HASH, "Must provide a Chain Root Hash for 'prod' or 'test' environment");
+    chainRootHashFinal = process.env.CHAIN_ROOT_HASH;
+  }
+
   const config : IZNSCampaignConfig<SignerWithAddress> = {
     env: process.env.ENV_LEVEL!,
     deployAdmin: deployer,
     governorAddresses,
     adminAddresses,
+    chainRootHash: chainRootHashFinal as string,
     domainToken: {
       name: process.env.DOMAIN_TOKEN_NAME ? process.env.DOMAIN_TOKEN_NAME : ZNS_DOMAIN_TOKEN_NAME,
       symbol: process.env.DOMAIN_TOKEN_SYMBOL ? process.env.DOMAIN_TOKEN_SYMBOL : ZNS_DOMAIN_TOKEN_SYMBOL,
diff --git a/src/deploy/campaign/types.ts b/src/deploy/campaign/types.ts
@@ -24,6 +24,7 @@ export interface IZNSCampaignConfig <Signer> extends IDeployCampaignConfig<Signe
   deployAdmin : Signer;
   governorAddresses : Array<string>;
   adminAddresses : Array<string>;
+  chainRootHash : string;
   domainToken : {
     name : string;
     symbol : string;
@@ -67,4 +68,4 @@ export interface IZNSContracts extends IContractState<ZNSContract> {
   rootRegistrar : ZNSRootRegistrar;
   fixedPricer : ZNSFixedPricer;
   subRegistrar : ZNSSubRegistrar;
-}
+}
diff --git a/src/deploy/missions/contracts/registry.ts b/src/deploy/missions/contracts/registry.ts
@@ -24,7 +24,13 @@ IZNSContracts
   instanceName = znsNames.registry.instance;
 
   async deployArgs () : Promise<TDeployArgs> {
-    const { accessController } = this.campaign;
-    return [ await accessController.getAddress() ];
+    const {
+      accessController,
+      config: {
+        chainRootHash,
+      },
+    } = this.campaign;
+
+    return [ await accessController.getAddress(), chainRootHash ];
   }
 }
diff --git a/test/L2-BRIDGE-TEST/MultiZNS.test.ts b/test/L2-BRIDGE-TEST/MultiZNS.test.ts
@@ -8,7 +8,7 @@ import {
   AccessType,
   distrConfigEmpty,
   DISTRIBUTION_LOCKED_NOT_EXIST_ERR,
-  fullDistrConfigEmpty,
+  fullDistrConfigEmpty, hashDomainLabel,
   NOT_AUTHORIZED_ERR,
   NOT_OWNER_OF_ERR,
 } from "../helpers";
@@ -17,41 +17,44 @@ import * as ethers from "ethers";
 import { ZNSChainResolver, ZNSChainResolver__factory } from "../../typechain";
 
 
-describe("MultiZNS", () => {
-  let zns : IZNSContracts;
+describe.only("MultiZNS", () => {
+  let znsL1 : IZNSContracts;
+  let znsL2 : IZNSContracts;
 
   let deployAdmin : SignerWithAddress;
   let registryMock : SignerWithAddress;
 
-  let config : IZNSCampaignConfig<SignerWithAddress>;
+  let campaignConfig : IZNSCampaignConfig<SignerWithAddress>;
 
   const chainDomainLabel = "zchain";
   let chainDomainHash : string;
+  let rootDomainL2Hash : string;
 
   let chainResolver : ZNSChainResolver;
 
   before(async () => {
     [ deployAdmin, registryMock ] = await hre.ethers.getSigners();
 
-    config = await getConfig({
+    campaignConfig = await getConfig({
       deployer: deployAdmin,
       zeroVaultAddress: deployAdmin.address,
+      chainRootHash: ethers.ZeroHash,
     });
 
-    const campaign = await runZnsCampaign({ config });
+    const campaign = await runZnsCampaign({ config: campaignConfig });
 
-    zns = campaign.state.contracts;
+    znsL1 = campaign.state.contracts;
 
-    await zns.meowToken.mint(deployAdmin.address, 1000000000000000000000n);
-    await zns.meowToken.connect(deployAdmin).approve(zns.treasury.target, ethers.MaxUint256);
+    await znsL1.meowToken.mint(deployAdmin.address, 1000000000000000000000n);
+    await znsL1.meowToken.connect(deployAdmin).approve(znsL1.treasury.target, ethers.MaxUint256);
 
     // TODO multi: add deploy mission for ChainResolver if decided to leave it!
     const chainResFact = new ZNSChainResolver__factory(deployAdmin);
     chainResolver = await hre.upgrades.deployProxy(
       chainResFact,
       [
-        zns.accessController.target,
-        zns.registry.target,
+        znsL1.accessController.target,
+        znsL1.registry.target,
       ],
       {
         kind: "uups",
@@ -61,16 +64,18 @@ describe("MultiZNS", () => {
   });
 
   describe("Bridging Single Chain Specific Domain", () => {
-    it.only("should register a new root domain for a chain regularly", async () => {
+    it("should register a new root domain for a chain regularly", async () => {
       chainDomainHash = await registrationWithSetup({
-        zns,
+        zns: znsL1,
         user: deployAdmin,
         domainLabel: chainDomainLabel,
         fullConfig: fullDistrConfigEmpty,
       });
 
+      expect(chainDomainHash).to.equal(hashDomainLabel(chainDomainLabel));
+
       // should be LOCKED to not allow any subdomains on L1
-      const { accessType } = await zns.subRegistrar.distrConfigs(chainDomainHash);
+      const { accessType } = await znsL1.subRegistrar.distrConfigs(chainDomainHash);
       expect(accessType).to.equal(0n);
 
       // set ChainResolver ?!?!?!
@@ -88,63 +93,63 @@ describe("MultiZNS", () => {
       );
 
       // transfer Domain Token to ZNSRegistry. It CAN NOT be transfered back! This is a final immutable operation!
-      await zns.domainToken.connect(deployAdmin).transferFrom(
+      await znsL1.domainToken.connect(deployAdmin).transferFrom(
         deployAdmin.address,
-        zns.registry.target,
+        znsL1.registry.target,
         BigInt(chainDomainHash)
       );
 
       // [AS A LAST OPERATION] change owner to ZNSRegistry to signify that a domain is on another network
-      await zns.registry.connect(deployAdmin).updateDomainOwner(chainDomainHash, zns.registry.target);
+      await znsL1.registry.connect(deployAdmin).updateDomainOwner(chainDomainHash, znsL1.registry.target);
 
       // make sure no domain related functions are available to the domain creator now
       await expect(
-        zns.registry.connect(deployAdmin).updateDomainOwner(
+        znsL1.registry.connect(deployAdmin).updateDomainOwner(
           chainDomainHash,
           deployAdmin.address
         )
-      ).to.be.revertedWithCustomError(zns.registry, NOT_AUTHORIZED_ERR);
+      ).to.be.revertedWithCustomError(znsL1.registry, NOT_AUTHORIZED_ERR);
 
       await expect(
-        zns.addressResolver.connect(deployAdmin).setAddress(
+        znsL1.addressResolver.connect(deployAdmin).setAddress(
           chainDomainHash,
           deployAdmin.address
         )
-      ).to.be.revertedWithCustomError(zns.registry, NOT_AUTHORIZED_ERR);
+      ).to.be.revertedWithCustomError(znsL1.registry, NOT_AUTHORIZED_ERR);
 
       await expect(
-        zns.subRegistrar.connect(deployAdmin).setDistributionConfigForDomain(
+        znsL1.subRegistrar.connect(deployAdmin).setDistributionConfigForDomain(
           chainDomainHash,
           {
             ...distrConfigEmpty,
             accessType: AccessType.OPEN,
           }
         )
-      ).to.be.revertedWithCustomError(zns.registry, NOT_AUTHORIZED_ERR);
+      ).to.be.revertedWithCustomError(znsL1.registry, NOT_AUTHORIZED_ERR);
 
       // can't Revoke or Reclaim domain
       await expect(
-        zns.rootRegistrar.connect(deployAdmin).revokeDomain(chainDomainHash)
-      ).to.be.revertedWithCustomError(zns.rootRegistrar, NOT_OWNER_OF_ERR);
+        znsL1.rootRegistrar.connect(deployAdmin).revokeDomain(chainDomainHash)
+      ).to.be.revertedWithCustomError(znsL1.rootRegistrar, NOT_OWNER_OF_ERR);
 
       await expect(
-        zns.rootRegistrar.connect(deployAdmin).reclaimDomain(chainDomainHash)
-      ).to.be.revertedWithCustomError(zns.rootRegistrar, NOT_OWNER_OF_ERR);
+        znsL1.rootRegistrar.connect(deployAdmin).reclaimDomain(chainDomainHash)
+      ).to.be.revertedWithCustomError(znsL1.rootRegistrar, NOT_OWNER_OF_ERR);
 
       // make sure no one can register subdomains
       await expect(
         registrationWithSetup({
-          zns,
+          zns: znsL1,
           user: deployAdmin,
           parentHash: chainDomainHash,
           domainLabel: "test",
           fullConfig: fullDistrConfigEmpty,
         })
-      ).to.be.revertedWithCustomError(zns.subRegistrar, DISTRIBUTION_LOCKED_NOT_EXIST_ERR);
+      ).to.be.revertedWithCustomError(znsL1.subRegistrar, DISTRIBUTION_LOCKED_NOT_EXIST_ERR);
 
-      const record = await zns.registry.getDomainRecord(chainDomainHash);
-      expect(record.owner).to.equal(zns.registry.target);
-      expect(record.resolver).to.equal(zns.addressResolver.target);
+      const record = await znsL1.registry.getDomainRecord(chainDomainHash);
+      expect(record.owner).to.equal(znsL1.registry.target);
+      expect(record.resolver).to.equal(znsL1.addressResolver.target);
 
       // check resolver data
       const resolverData = await chainResolver.resolveChainDataStruct(chainDomainHash);
@@ -153,5 +158,104 @@ describe("MultiZNS", () => {
       expect(resolverData.znsRegistryOnChain).to.equal(znsRegistryOnChain);
       expect(resolverData.auxData).to.equal(auxData);
     });
+
+    it("deploy ZNS L2", async () => {
+      campaignConfig = {
+        ...campaignConfig,
+        chainRootHash: chainDomainHash,
+      };
+      const campaignL2 = await runZnsCampaign({ config: campaignConfig });
+
+      znsL2 = campaignL2.state.contracts;
+
+      await znsL2.meowToken.mint(deployAdmin.address, 1000000000000000000000n);
+      await znsL2.meowToken.connect(deployAdmin).approve(znsL2.treasury.target, ethers.MaxUint256);
+    });
+
+    it("should set up ZNS L2 with proper domain as root", async () => {
+      // check that the domain is properly set up
+      const chainRootHash = await znsL2.registry.CHAIN_ROOT_HASH();
+      expect(chainRootHash).to.equal(chainDomainHash);
+
+      // check pricer setup
+      const distrConfigFromL2 = await znsL2.curvePricer.priceConfigs(chainRootHash);
+      expect(distrConfigFromL2.maxPrice).to.deep.equal(campaignConfig.rootPriceConfig.maxPrice);
+      expect(distrConfigFromL2.minPrice).to.deep.equal(campaignConfig.rootPriceConfig.minPrice);
+      expect(distrConfigFromL2.maxLength).to.equal(campaignConfig.rootPriceConfig.maxLength);
+      expect(distrConfigFromL2.baseLength).to.equal(campaignConfig.rootPriceConfig.baseLength);
+      expect(distrConfigFromL2.precisionMultiplier).to.equal(campaignConfig.rootPriceConfig.precisionMultiplier);
+      expect(distrConfigFromL2.feePercentage).to.equal(campaignConfig.rootPriceConfig.feePercentage);
+      expect(distrConfigFromL2.isSet).to.equal(true);
+
+      // check treasury setup
+      const paymentConfigFromL2 = await znsL2.treasury.paymentConfigs(chainRootHash);
+      expect(paymentConfigFromL2.token).to.equal(znsL2.meowToken.target);
+      expect(paymentConfigFromL2.beneficiary).to.equal(campaignConfig.zeroVaultAddress);
+    });
+
+    it("should register a new root domain on L2", async () => {
+      const rootDomainL2Label = "wilderworld";
+      rootDomainL2Hash = await registrationWithSetup({
+        zns: znsL2,
+        user: deployAdmin,
+        domainLabel: rootDomainL2Label,
+        // TODO multi: add a config here to check later in test
+        fullConfig: fullDistrConfigEmpty,
+      });
+
+      // validate it hashed properly
+      const chainRootHash = await znsL2.registry.CHAIN_ROOT_HASH();
+      const abiCoder = new ethers.AbiCoder();
+      const encoded = abiCoder.encode(
+        ["bytes32", "bytes32"],
+        [chainRootHash, hashDomainLabel(rootDomainL2Label)]
+      );
+      const rootDomainHashRef = ethers.solidityPackedKeccak256(
+        ["bytes"],
+        [encoded]
+      );
+
+      expect(rootDomainL2Hash).to.equal(rootDomainHashRef);
+
+      // check owner and domain token
+      const record = await znsL2.registry.getDomainRecord(rootDomainL2Hash);
+      expect(record.owner).to.equal(deployAdmin.address);
+      expect(record.resolver).to.equal(znsL2.addressResolver.target);
+
+      const domainTokenOwner = await znsL2.domainToken.ownerOf(BigInt(rootDomainL2Hash));
+      expect(domainTokenOwner).to.equal(deployAdmin.address);
+    });
+
+    it("should register a subdomain on L2", async () => {
+      const subDomainLabel = "wheels";
+      const subDomainHash = await registrationWithSetup({
+        zns: znsL2,
+        user: deployAdmin,
+        parentHash: rootDomainL2Hash,
+        domainLabel: subDomainLabel,
+        fullConfig: fullDistrConfigEmpty,
+      });
+
+      // validate hashing
+      const abiCoder = new ethers.AbiCoder();
+      const encoded = abiCoder.encode(
+        ["bytes32", "bytes32"],
+        [rootDomainL2Hash, hashDomainLabel(subDomainLabel)]
+      );
+      const subDomainHashRef = ethers.solidityPackedKeccak256(
+        ["bytes"],
+        [encoded]
+      );
+
+      expect(subDomainHash).to.equal(subDomainHashRef);
+
+      // check owner and domain token
+      const record = await znsL2.registry.getDomainRecord(subDomainHash);
+      expect(record.owner).to.equal(deployAdmin.address);
+      expect(record.resolver).to.equal(znsL2.addressResolver.target);
+
+      const domainTokenOwner = await znsL2.domainToken.ownerOf(BigInt(subDomainHash));
+      expect(domainTokenOwner).to.equal(deployAdmin.address);
+    });
   });
 });
