Add conditional network1 tests

codegen/common.ts

@@ -25,6 +25,7 @@ export type Operator = {
 
 export type CodegenContext = {
   libFheAddress: string;
+  optimisticRequiresEnabled: boolean;
 };
 
 export enum OperatorArguments {
@@ -242,10 +243,12 @@ export function networkCodegenContext(network: Network): CodegenContext {
     case Network.Evmos:
       return {
         libFheAddress: '0x000000000000000000000000000000000000005d',
+        optimisticRequiresEnabled: true,
       };
     case Network.Network1:
       return {
         libFheAddress: '0x010000000000000000000000000000000000005D',
+        optimisticRequiresEnabled: false,
       };
   }
 }

codegen/main.ts

@@ -22,6 +22,7 @@ function generateAllFiles() {
     'test/generated.ts',
     `
     export const FHE_LIB_ADDRESS = '${context.libFheAddress}';
+    export const OPTIMISTIC_REQUIRES_ENABLED = '${context.optimisticRequiresEnabled}';
   `,
   );
 }

test/generated.ts

@@ -1 +1,2 @@
 export const FHE_LIB_ADDRESS = '0x000000000000000000000000000000000000005d';
+export const OPTIMISTIC_REQUIRES_ENABLED = 'true';

test/tfheOperations/manual.ts

@@ -3,8 +3,10 @@ import { expect } from 'chai';
 import { ethers } from 'hardhat';
 
 import type { TFHEManualTestSuite } from '../../types/contracts/tests/TFHEManualTestSuite';
+import { OPTIMISTIC_REQUIRES_ENABLED } from '../generated';
 import { createInstances } from '../instance';
 import { getSigners, initSigners } from '../signers';
+import { testRequires } from '../utils';
 
 async function deployTfheManualTestFixture(): Promise<TFHEManualTestSuite> {
   const signers = await getSigners();
@@ -67,32 +69,34 @@ describe('TFHE manual operations', function () {
     expect(res).to.equal(0);
   });
 
-  it('optimistic require with true succeeds', async function () {
-    await this.contract.test_opt_req(true);
-  });
-
-  it('optimistic require with false fails', async function () {
-    try {
-      await this.contract.test_opt_req(false);
-      fail('This should fail');
-    } catch (e: any) {
-      expect(e.message).to.contain('execution reverted');
-    }
-  });
-
-  it('stateful optimistic require with true succeeds', async function () {
-    const res = await this.contract.test_opt_req_stateful(true);
-    const receipt = await res.wait();
-    expect(receipt.status).to.equal(1);
-  });
-
-  it('stateful optimistic require with false fails', async function () {
-    const res = await this.contract.test_opt_req_stateful(false);
-    try {
-      const _ = await res.wait();
-      fail('This should fail');
-    } catch (e: any) {
-      expect(e.toString()).to.contain('transaction execution reverted');
-    }
-  });
+  if (OPTIMISTIC_REQUIRES_ENABLED) {
+    it('optimistic require with true succeeds', async function () {
+      await this.contract.test_opt_req(true);
+    });
+
+    it('optimistic require with false fails', async function () {
+      try {
+        await this.contract.test_opt_req(false);
+        fail('This should fail');
+      } catch (e: any) {
+        expect(e.message).to.contain('execution reverted');
+      }
+    });
+
+    it('stateful optimistic require with true succeeds', async function () {
+      const res = await this.contract.test_opt_req_stateful(true);
+      const receipt = await res.wait();
+      expect(receipt.status).to.equal(1);
+    });
+
+    it('stateful optimistic require with false fails', async function () {
+      const res = await this.contract.test_opt_req_stateful(false);
+      try {
+        const _ = await res.wait();
+        fail('This should fail');
+      } catch (e: any) {
+        expect(e.toString()).to.contain('transaction execution reverted');
+      }
+    });
+  }
 });