refactor: testgen

Author: PacificYield

contracts/codegen/generateOverloads.ts

@@ -1,12 +1,14 @@
 import { mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
 
 import { validateFHETypes, validateOperators } from './common';
+import { generateOverloads } from './generateOverloads';
 import { ALL_OPERATORS } from './operators';
 import operatorsPrices from './operatorsPrices.json';
 import { generateSolidityFHEGasLimit } from './payments';
 import { generateSolidityImplLib, generateSolidityTFHELibAndOverloads } from './templates';
 import {
-  generateSolidityOverloads,
+  generateSolidityOverloadTestFiles,
   generateSolidityUnitTestContracts,
   generateTypeScriptTestCode,
   splitOverloadsToShards,
@@ -40,8 +42,15 @@ function generateAllFiles() {
   writeFileSync('lib/TFHE.sol', tfheSolSource);
   writeFileSync('contracts/FHEGasLimit.sol', generateSolidityFHEGasLimit(operatorsPrices));
 
-  /// Generate overload, split them into shars, and generate Solidity contracts to be used for unit test files.
-  const overloadShards = splitOverloadsToShards(generateSolidityOverloads(ALL_OPERATORS, ALL_FHE_TYPES));
+  // TODO: For now, the testgen only supports automatically generated tests for euintXX.
+  /// Generate overloads, split them into shards, and generate Solidity contracts to be used for TypeScript unit test files.
+  writeFileSync(
+    `${path.resolve(__dirname)}/overloads.json`,
+    JSON.stringify(generateOverloads(ALL_FHE_TYPES), (_key, value) =>
+      typeof value === 'bigint' ? value.toString() : value,
+    ),
+  );
+  const overloadShards = splitOverloadsToShards(generateSolidityOverloadTestFiles(ALL_OPERATORS, ALL_FHE_TYPES));
   mkdirSync('contracts/tests', { recursive: true });
   overloadShards.forEach((os) => {
     writeFileSync(`examples/tests/TFHETestSuite${os.shardNumber}.sol`, generateSolidityUnitTestContracts(os));

contracts/codegen/main.ts

@@ -13,7 +13,7 @@ import {
 import { overloadTests } from './overloadTests';
 import { getUint } from './utils';
 
-export function generateSolidityOverloads(operators: Operator[], fheTypes: FheType[]): OverloadSignature[] {
+export function generateSolidityOverloadTestFiles(operators: Operator[], fheTypes: FheType[]): OverloadSignature[] {
   const signatures: OverloadSignature[] = [];
 
   // Exclude types that do not support any operators.

contracts/codegen/overloads.json

@@ -9,3 +9,35 @@ export const getUint = (bits: number) => {
   if (bits < 8) throw new Error('Bits must be greater than 8');
   return `uint${bits}`;
 };
+/**
+ * Finds the minimum value among a list of `bigint` numbers.
+ *
+ * @param args - An array of `bigint` values to compare.
+ * @returns The smallest `bigint` value from the provided arguments.
+ */
+export const findMinimumValueInBigIntArray = (...args: bigint[]) => {
+  return args.reduce((min, e) => (e < min ? e : min), args[0]);
+};
+
+/**
+ * Finds the maximum value among a list of `bigint` numbers.
+ *
+ * @param args - An array of `bigint` numbers to compare.
+ * @returns The largest `bigint` value from the provided arguments.
+ */
+export const findMaximumValueInBigIntArray = (...args: bigint[]) => {
+  return args.reduce((max, e) => (e > max ? e : max), args[0]);
+};
+
+/**
+ * Generates a random number within a specified bit range.
+ *
+ * @param bits - The number of bits to determine the range of the generated number.
+ * @returns A random BigInt number within the range defined by the number of bits.
+ */
+export const generateRandomNumber = (bits: number) => {
+  const power = BigInt(Math.pow(2, bits) - 1);
+  const maxRange = findMinimumValueInBigIntArray(power, BigInt(Number.MAX_SAFE_INTEGER));
+  const subtract = findMaximumValueInBigIntArray(BigInt(Math.floor(Math.random() * Number(maxRange))), 1n);
+  return findMaximumValueInBigIntArray(power - subtract, 1n);
+};