@coti-io/coti-contracts 1.1.0 → 1.2.0

package/test/utils/mpc/Unsigned256BitIntegers.test.ts

@@ -1,1124 +0,0 @@
-import hre from "hardhat"
-import { expect } from "chai"
-import { setupAccounts } from "../accounts"
-import { ItUint256Struct } from "../../../typechain-types/contracts/mocks/utils/mpc/Miscellaneous256BitTestsContract"
-import { decryptUint256, encryptUint256, generateRandomNumber } from "./helpers"
-
-const MAX_UINT256 = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
-
-async function deploy() {
-  const [owner, otherAccount] = await setupAccounts()
-
-  const extendedMiscellaneousTestsContract = await hre.ethers.getContractFactory("Miscellaneous256BitTestsContract")
-  const extendedMiscellaneousTests = await extendedMiscellaneousTestsContract.connect(owner).deploy()
-  await extendedMiscellaneousTests.waitForDeployment()
-
-  const extendedArithmeticTestsContract = await hre.ethers.getContractFactory("Arithmetic256BitTestsContract")
-  const extendedArithmeticTests = await extendedArithmeticTestsContract.connect(owner).deploy()
-  await extendedArithmeticTests.waitForDeployment()
-
-  const extendedBitwiseTestsContract = await hre.ethers.getContractFactory("Bitwise256BitTestsContract")
-  const extendedBitwiseTests = await extendedBitwiseTestsContract.connect(owner).deploy()
-  await extendedBitwiseTests.waitForDeployment()
-
-  const extendedComparisonTestsContract = await hre.ethers.getContractFactory("Comparison256BitTestsContract")
-  const extendedComparisonTests = await extendedComparisonTestsContract.connect(owner).deploy()
-  await extendedComparisonTests.waitForDeployment()
-
-  return { extendedMiscellaneousTests, extendedArithmeticTests, extendedBitwiseTests, extendedComparisonTests, owner }
-}
-
-describe("MPC Core", function () {
-  let deployment: Awaited<ReturnType<typeof deploy>>
-
-  before(async function () {
-    deployment = await deploy()
-  })
-
-  describe("256-bit unsigned integers", function () {
-    it("validateCiphertext", async function () {
-        const { extendedMiscellaneousTests, owner } = deployment
-
-        // Generate two arrays of 10 random 256-bit integers
-        const numbers: bigint[] = []
-        const encryptedNumbers: ItUint256Struct[] = []
-
-        for (let i = 0; i < 1; i++) {
-          // Generate random 256-bit integers
-          const number = generateRandomNumber(32)
-
-          numbers.push(number)
-          encryptedNumbers.push(
-            await encryptUint256(
-              number,
-              owner,
-              await extendedMiscellaneousTests.getAddress(),
-              extendedMiscellaneousTests.validateCiphertextTest.fragment.selector
-            ) as ItUint256Struct
-          )
-        }
-
-        // Call validateCiphertextTest with the array
-        await (await extendedMiscellaneousTests.validateCiphertextTest(encryptedNumbers)).wait()
-
-        // Verify results
-        for (let i = 0; i < 1; i++) {
-            const result = await extendedMiscellaneousTests.numbers2(i)
-            expect(result).to.equal(numbers[i])
-        }
-    })
-
-    it("offBoardToUser", async function () {
-      const { extendedMiscellaneousTests, owner } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        numbers.push(generateRandomNumber(32))
-      }
-
-      // Call validateCiphertextTest with the array
-      await (await extendedMiscellaneousTests.offBoardToUserTest(numbers)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-          const ctNumber = await extendedMiscellaneousTests.ctNumbers2(i)
-
-          const result = await decryptUint256(ctNumber, owner)
-
-          expect(result).to.equal(numbers[i])
-      }
-    })
-
-    it("setPublic", async function () {
-        const { extendedMiscellaneousTests } = deployment
-
-        // Generate two arrays of 10 random 256-bit integers
-        const numbers: bigint[] = []
-
-        for (let i = 0; i < 1; i++) {
-            // Generate random 256-bit integers
-            numbers.push(generateRandomNumber(32))
-        }
-
-        // Call setPublicTest with the arrays
-        await (await extendedMiscellaneousTests.setPublicTest(numbers)).wait()
-
-        // Verify results
-        for (let i = 0; i < 1; i++) {
-            const result = await extendedMiscellaneousTests.numbers2(i)
-            expect(result).to.equal(numbers[i])
-        }
-    })
-
-    it("rand", async function () {
-        const { extendedMiscellaneousTests } = deployment
-
-        const length: bigint = generateRandomNumber(1)
-
-        // Call setPublicTest with the arrays
-        await (await extendedMiscellaneousTests.randTest2(length)).wait()
-
-        // Verify results
-        for (let i = 0; i < length; i++) {
-            const result = await extendedMiscellaneousTests.numbers2(i)
-            expect(result).to.not.equal(0n)
-        }
-    })
-
-    it("randBoundedBits", async function () {
-      const { extendedMiscellaneousTests } = deployment
-
-      // Generate an array of 10 random 8-bit integers
-      const numbers: bigint[] = []
-
-      while (numbers.length < 1) {
-          // Generate random 8-bit integers
-          numbers.push(generateRandomNumber(1))
-      }
-
-      // Call setPublicTest with the arrays
-      await (await extendedMiscellaneousTests.randBoundedBitsTest2(numbers)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-          const result = await extendedMiscellaneousTests.numbers2(i)
-          expect(result).to.not.equal(0n)
-      }
-    })
-    
-    it("transfer", async function () {
-      const { extendedMiscellaneousTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const aArr: bigint[] = []
-      const bArr: bigint[] = []
-      const amountArr: bigint[] = []
-      const newA: bigint[] = []
-      const newB: bigint[] = []
-      const successArr: boolean[] = []
-
-      while (aArr.length < 1) {
-          // Generate random 256-bit integers
-
-          const a = generateRandomNumber(30)
-          const b = generateRandomNumber(30)
-          const amount = generateRandomNumber(30)
-
-          if (b + amount > MAX_UINT256) continue
-
-          aArr.push(a)
-          bArr.push(b)
-          amountArr.push(amount)
-
-          const success = a >= amount
-
-          newA.push(success ? a - amount : a)
-          newB.push(success ? b + amount : b)
-          successArr.push(success)
-      }
-
-      // Call transferTest with the arrays
-      await (await extendedMiscellaneousTests.transferTest(aArr, bArr, amountArr)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-          const a = await extendedMiscellaneousTests.a2(i)
-          const b = await extendedMiscellaneousTests.b2(i)
-          const success = await extendedMiscellaneousTests.success(i)
-
-          expect(a).to.equal(newA[i])
-          expect(b).to.equal(newB[i])
-          expect(success).to.equal(successArr[i])
-      }
-    })
-
-    it("transferWithAllowance", async function () {
-      const { extendedMiscellaneousTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const aArr: bigint[] = []
-      const bArr: bigint[] = []
-      const amountArr: bigint[] = []
-      const allowanceArr: bigint[] = []
-      const newA: bigint[] = []
-      const newB: bigint[] = []
-      const successArr: boolean[] = []
-      const newAllowanceArr: bigint[] = []
-
-      while (aArr.length < 1) {
-          // Generate random 256-bit integers
-
-          const a = generateRandomNumber(30)
-          const b = generateRandomNumber(30)
-          const amount = generateRandomNumber(30)
-          const allowance = generateRandomNumber(30)
-
-          if (b + amount > MAX_UINT256) continue
-
-          aArr.push(a)
-          bArr.push(b)
-          amountArr.push(amount)
-          allowanceArr.push(allowance)
-
-          const success = a >= amount && amount <= allowance
-
-          newA.push(success ? a - amount : a)
-          newB.push(success ? b + amount : b)
-          successArr.push(success)
-          newAllowanceArr.push(success ? allowance - amount : allowance)
-      }
-
-      // Call transferWithAllowanceTest with the arrays
-      await (await extendedMiscellaneousTests.transferWithAllowanceTest(aArr, bArr, amountArr, allowanceArr)).wait()
-      
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-          const a = await extendedMiscellaneousTests.a2(i)
-          const b = await extendedMiscellaneousTests.b2(i)
-          const success = await extendedMiscellaneousTests.success(i)
-          const allowance = await extendedMiscellaneousTests.allowance2(i)
-
-          expect(a).to.equal(newA[i])
-          expect(b).to.equal(newB[i])
-          expect(success).to.equal(successArr[i])
-          expect(allowance).to.equal(newAllowanceArr[i])
-      }
-    })
-
-    it("add", async function () {
-      const { extendedArithmeticTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(30)
-        const num2 = generateRandomNumber(30)
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 + num2)
-      }
-
-      // Call addTest with the arrays
-      await (await extendedArithmeticTests.addTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedArithmeticTests.numbers2(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("checkedAdd", async function () {
-      const { extendedArithmeticTests, owner } = deployment
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = generateRandomNumber(32)
-        
-        if (num1 + num2 <= MAX_UINT256) { // max uint256
-          // Call checkedAddTest
-          await (await extendedArithmeticTests.checkedAddTest(num1, num2)).wait()
-
-          const result = await extendedArithmeticTests.numbers2(0)
-          expect(result).to.equal(num1 + num2)
-        } else {
-          // Expect revert
-          const tx = await extendedArithmeticTests.checkedAddTest(num1, num2)
-
-          try {
-            await tx.wait()
-          } catch (e) {
-            const receipt = await owner.provider?.getTransactionReceipt(tx.hash)
-            expect(receipt?.status).to.be.equal(0)
-          }
-        }
-      }
-    })
-
-    it("checkedAddWithOverflowBit", async function () {
-      const { extendedArithmeticTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedOverflows: boolean[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = generateRandomNumber(32)
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedOverflows.push(num1 + num2 > MAX_UINT256)
-        expectedResults.push(num1 + num2)
-      }
-
-      // Call checkedAddWithOverflowBitTest with the arrays
-      await (await extendedArithmeticTests.checkedAddWithOverflowBitTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const bit = await extendedArithmeticTests.overflows(i)
-        const bitLHS = await extendedArithmeticTests.overflowsLHS(i)
-        const bitRHS = await extendedArithmeticTests.overflowsRHS(i)
-        const result = await extendedArithmeticTests.numbers2(i)
-        const resultLHS = await extendedArithmeticTests.numbersLHS2(i)
-        const resultRHS = await extendedArithmeticTests.numbersRHS2(i)
-
-        expect(bit).to.equal(expectedOverflows[i])
-        expect(bitLHS).to.equal(expectedOverflows[i])
-        expect(bitRHS).to.equal(expectedOverflows[i])
-
-        if (bit) {
-          expect(result).to.not.equal(expectedResults[i])
-          expect(resultLHS).to.not.equal(expectedResults[i])
-          expect(resultRHS).to.not.equal(expectedResults[i])
-        } else {
-          expect(result).to.equal(expectedResults[i])
-          expect(resultLHS).to.equal(expectedResults[i])
-          expect(resultRHS).to.equal(expectedResults[i])
-        }
-      }
-    })
-
-    it("sub", async function () {
-        const { extendedArithmeticTests } = deployment
-  
-        // Generate two arrays of 10 random 256-bit integers
-        const numbers1: bigint[] = []
-        const numbers2: bigint[] = []
-        const expectedResults: bigint[] = []
-  
-        for (let i = 0; i < 1; i++) {
-          // Generate random 256-bit integers
-          const num1 = generateRandomNumber(32)
-          const num2 = generateRandomNumber(32)
-          
-          if (num1 >= num2) {
-              numbers1.push(num1)
-              numbers2.push(num2)
-              expectedResults.push(num1 - num2)
-          } else {
-            numbers1.push(num2)
-            numbers2.push(num1)
-            expectedResults.push(num2 - num1)
-          }
-        }
-  
-        // Call subTest with the arrays
-        await (await extendedArithmeticTests.subTest(numbers1, numbers2)).wait()
-  
-        // Verify results
-        for (let i = 0; i < 1; i++) {
-          const result = await extendedArithmeticTests.numbers2(i)
-          expect(result).to.equal(expectedResults[i])
-        }
-    })
-
-    it("checkedSub", async function () {
-      const { extendedArithmeticTests, owner } = deployment
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = generateRandomNumber(32)
-        
-        if (num1 - num2 >= 0n) {
-          // Call checkedSubTest
-          await (await extendedArithmeticTests.checkedSubTest(num1, num2)).wait()
-
-          const result = await extendedArithmeticTests.numbers2(0)
-          expect(result).to.equal(num1 - num2)
-        } else {
-          // Expect revert
-          const tx = await extendedArithmeticTests.checkedSubTest(num1, num2)
-
-          try {
-            await tx.wait()
-          } catch (e) {
-            const receipt = await owner.provider?.getTransactionReceipt(tx.hash)
-            expect(receipt?.status).to.be.equal(0)
-          }
-        }
-      }
-    })
-
-    it("checkedSubWithOverflowBit", async function () {
-      const { extendedArithmeticTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedOverflows: boolean[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = generateRandomNumber(32)
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedOverflows.push(num1 - num2 < 0n)
-        expectedResults.push(num1 - num2)
-      }
-
-      // Call checkedSubWithOverflowBitTest with the arrays
-      await (await extendedArithmeticTests.checkedSubWithOverflowBitTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const bit = await extendedArithmeticTests.overflows(i)
-        const bitLHS = await extendedArithmeticTests.overflowsLHS(i)
-        const bitRHS = await extendedArithmeticTests.overflowsRHS(i)
-        const result = await extendedArithmeticTests.numbers2(i)
-        const resultLHS = await extendedArithmeticTests.numbersLHS2(i)
-        const resultRHS = await extendedArithmeticTests.numbersRHS2(i)
-
-        expect(bit).to.equal(expectedOverflows[i])
-        expect(bitLHS).to.equal(expectedOverflows[i])
-        expect(bitRHS).to.equal(expectedOverflows[i])
-
-        if (bit) {
-          expect(result).to.not.equal(expectedResults[i])
-          expect(resultLHS).to.not.equal(expectedResults[i])
-          expect(resultRHS).to.not.equal(expectedResults[i])
-        } else {
-          expect(result).to.equal(expectedResults[i])
-          expect(resultLHS).to.equal(expectedResults[i])
-          expect(resultRHS).to.equal(expectedResults[i])
-        }
-      }
-    })
-
-    it("mul", async function () {
-      const { extendedArithmeticTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      while (numbers1.length < 1) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(17)
-        const num2 = generateRandomNumber(17)
-
-        if (num1 * num2 > MAX_UINT256) continue
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 * num2)
-      }
-
-      // Call addTest with the arrays
-      await (await extendedArithmeticTests.mulTest(numbers1, numbers2, 0n, { gasLimit: 80000000 })).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedArithmeticTests.numbers2(i)
-
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("mulLHS", async function () {
-      const { extendedArithmeticTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      while (numbers1.length < 1) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(17)
-        const num2 = generateRandomNumber(17)
-
-        if (num1 * num2 > MAX_UINT256) continue
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 * num2)
-      }
-
-      // Call addTest with the arrays
-      await (await extendedArithmeticTests.mulTest(numbers1, numbers2, 1n, { gasLimit: 80000000 })).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedArithmeticTests.numbers2(i)
-
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("mulRHS", async function () {
-      const { extendedArithmeticTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      while (numbers1.length < 1) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(17)
-        const num2 = generateRandomNumber(17)
-
-        if (num1 * num2 > MAX_UINT256) continue
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 * num2)
-      }
-
-      // Call addTest with the arrays
-      await (await extendedArithmeticTests.mulTest(numbers1, numbers2, 2n, { gasLimit: 80000000 })).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedArithmeticTests.numbers2(i)
-
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("checkedMul", async function () {
-      const { extendedArithmeticTests, owner } = deployment
-
-      for (let i = 0; i < 10; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(17)
-        const num2 = generateRandomNumber(17)
-        
-        if (num1 * num2 <= MAX_UINT256) {
-          // Call checkedSubTest
-          await (await extendedArithmeticTests.checkedMulTest(num1, num2, 0n, { gasLimit: 80000000 })).wait()
-
-          const result = await extendedArithmeticTests.numbers2(0)
-          expect(result).to.equal(num1 * num2)
-        } else {
-          // Expect revert
-          const tx = await extendedArithmeticTests.checkedMulTest(num1, num2, 0n, { gasLimit: 80000000 })
-
-          try {
-            await tx.wait()
-          } catch (e) {
-            const receipt = await owner.provider?.getTransactionReceipt(tx.hash)
-            expect(receipt?.status).to.be.equal(0)
-          }
-        }
-      }
-    })
-
-    it("checkedMulLHS", async function () {
-      const { extendedArithmeticTests, owner } = deployment
-
-      for (let i = 0; i < 10; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(17)
-        const num2 = generateRandomNumber(17)
-        
-        if (num1 * num2 <= MAX_UINT256) {
-          // Call checkedSubTest
-          await (await extendedArithmeticTests.checkedMulTest(num1, num2, 1n, { gasLimit: 80000000 })).wait()
-
-          const result = await extendedArithmeticTests.numbers2(0)
-          expect(result).to.equal(num1 * num2)
-        } else {
-          // Expect revert
-          const tx = await extendedArithmeticTests.checkedMulTest(num1, num2, 1n, { gasLimit: 80000000 })
-
-          try {
-            await tx.wait()
-          } catch (e) {
-            const receipt = await owner.provider?.getTransactionReceipt(tx.hash)
-            expect(receipt?.status).to.be.equal(0)
-          }
-        }
-      }
-    })
-
-    it("checkedMulRHS", async function () {
-      const { extendedArithmeticTests, owner } = deployment
-
-      for (let i = 0; i < 10; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(17)
-        const num2 = generateRandomNumber(17)
-        
-        if (num1 * num2 <= MAX_UINT256) {
-          // Call checkedSubTest
-          await (await extendedArithmeticTests.checkedMulTest(num1, num2, 2n, { gasLimit: 80000000 })).wait()
-
-          const result = await extendedArithmeticTests.numbers2(0)
-          expect(result).to.equal(num1 * num2)
-        } else {
-          // Expect revert
-          const tx = await extendedArithmeticTests.checkedMulTest(num1, num2, 2n, { gasLimit: 80000000 })
-
-          try {
-            await tx.wait()
-          } catch (e) {
-            const receipt = await owner.provider?.getTransactionReceipt(tx.hash)
-            expect(receipt?.status).to.be.equal(0)
-          }
-        }
-      }
-    })
-
-    it("checkedMulWithOverflowBit", async function () {
-      const { extendedArithmeticTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedOverflows: boolean[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(17)
-        const num2 = generateRandomNumber(17)
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedOverflows.push(num1 * num2 > MAX_UINT256)
-        expectedResults.push(num1 * num2)
-      }
-
-      // Call checkedSubWithOverflowBitTest with the arrays
-      await (await extendedArithmeticTests.checkedMulWithOverflowBitTest(numbers1, numbers2, 0n, { gasLimit: 80000000 })).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const bit = await extendedArithmeticTests.overflows(i)
-        const result = await extendedArithmeticTests.numbers2(i)
-
-        expect(bit).to.equal(expectedOverflows[i])
-
-        if (bit) {
-          expect(result).to.not.equal(expectedResults[i])
-        } else {
-          expect(result).to.equal(expectedResults[i])
-        }
-      }
-    })
-
-    it("checkedMulWithOverflowBitLHS", async function () {
-      const { extendedArithmeticTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedOverflows: boolean[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(17)
-        const num2 = generateRandomNumber(17)
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedOverflows.push(num1 * num2 > MAX_UINT256)
-        expectedResults.push(num1 * num2)
-      }
-
-      // Call checkedSubWithOverflowBitTest with the arrays
-      await (await extendedArithmeticTests.checkedMulWithOverflowBitTest(numbers1, numbers2, 1n, { gasLimit: 80000000 })).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const bit = await extendedArithmeticTests.overflows(i)
-        const result = await extendedArithmeticTests.numbers2(i)
-
-        expect(bit).to.equal(expectedOverflows[i])
-
-        if (bit) {
-          expect(result).to.not.equal(expectedResults[i])
-        } else {
-          expect(result).to.equal(expectedResults[i])
-        }
-      }
-    })
-
-    it("checkedMulWithOverflowBitRHS", async function () {
-      const { extendedArithmeticTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedOverflows: boolean[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(17)
-        const num2 = generateRandomNumber(17)
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedOverflows.push(num1 * num2 > MAX_UINT256)
-        expectedResults.push(num1 * num2)
-      }
-
-      // Call checkedSubWithOverflowBitTest with the arrays
-      await (await extendedArithmeticTests.checkedMulWithOverflowBitTest(numbers1, numbers2, 2n, { gasLimit: 80000000 })).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const bit = await extendedArithmeticTests.overflows(i)
-        const result = await extendedArithmeticTests.numbers2(i)
-
-        expect(bit).to.equal(expectedOverflows[i])
-
-        if (bit) {
-          expect(result).to.not.equal(expectedResults[i])
-        } else {
-          expect(result).to.equal(expectedResults[i])
-        }
-      }
-    })
-
-    it("and", async function () {
-      const { extendedBitwiseTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = generateRandomNumber(32)
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 & num2)
-      }
-
-      // Call addTest with the arrays
-      await (await extendedBitwiseTests.andTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedBitwiseTests.numbers2(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("or", async function () {
-      const { extendedBitwiseTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = generateRandomNumber(32)
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 | num2)
-      }
-
-      // Call orTest with the arrays
-      await (await extendedBitwiseTests.orTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedBitwiseTests.numbers2(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("xor", async function () {
-      const { extendedBitwiseTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = generateRandomNumber(32)
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 ^ num2)
-      }
-
-      // Call xorTest with the arrays
-      await (await extendedBitwiseTests.xorTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedBitwiseTests.numbers2(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("shl", async function () {
-      const { extendedBitwiseTests } = deployment
-
-      // Generate an arrays of 10 random 256-bit integers and 10 random 8-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      while (numbers2.length < 1) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(16)
-        const num2 = generateRandomNumber(1)
-
-        if (num1 << num2 > MAX_UINT256) continue
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 << num2)
-      }
-
-      // Call xorTest with the arrays
-      await (await extendedBitwiseTests.shlTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedBitwiseTests.numbers2(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("shr", async function () {
-      const { extendedBitwiseTests } = deployment
-
-      // Generate an arrays of 10 random 256-bit integers and 10 random 8-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      while (numbers2.length < 1) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(16)
-        const num2 = generateRandomNumber(1)
-
-        if ((num1 & ((1n << num2) - 1n)) !== 0n) continue
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 >> num2)
-      }
-
-      // Call xorTest with the arrays
-      await (await extendedBitwiseTests.shrTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedBitwiseTests.numbers2(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("eq", async function () {
-      const { extendedComparisonTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: boolean[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = i % 2 === 0 ? generateRandomNumber(32) : num1
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 === num2)
-      }
-
-      // Call eqTest with the arrays
-      await (await extendedComparisonTests.eqTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedComparisonTests.boolResults(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("ne", async function () {
-      const { extendedComparisonTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: boolean[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = i % 2 === 0 ? generateRandomNumber(32) : num1
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 !== num2)
-      }
-
-      // Call neTest with the arrays
-      await (await extendedComparisonTests.neTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedComparisonTests.boolResults(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("ge", async function () {
-      const { extendedComparisonTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: boolean[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = i % 2 === 0 ? generateRandomNumber(32) : num1
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 >= num2)
-      }
-
-      // Call geTest with the arrays
-      await (await extendedComparisonTests.geTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedComparisonTests.boolResults(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("gt", async function () {
-      const { extendedComparisonTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: boolean[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = i % 2 === 0 ? generateRandomNumber(32) : num1
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 > num2)
-      }
-
-      // Call gtTest with the arrays
-      await (await extendedComparisonTests.gtTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedComparisonTests.boolResults(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("le", async function () {
-      const { extendedComparisonTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: boolean[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = i % 2 === 0 ? generateRandomNumber(32) : num1
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 <= num2)
-      }
-
-      // Call leTest with the arrays
-      await (await extendedComparisonTests.leTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedComparisonTests.boolResults(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("lt", async function () {
-      const { extendedComparisonTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: boolean[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = i % 2 === 0 ? generateRandomNumber(32) : num1
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 < num2)
-      }
-
-      // Call ltTest with the arrays
-      await (await extendedComparisonTests.ltTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedComparisonTests.boolResults(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("min", async function () {
-      const { extendedComparisonTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = i % 2 === 0 ? generateRandomNumber(32) : num1
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 <= num2 ? num1 : num2)
-      }
-
-      // Call minTest with the arrays
-      await (await extendedComparisonTests.minTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedComparisonTests.uintResults2(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-
-    it("max", async function () {
-      const { extendedComparisonTests } = deployment
-
-      // Generate two arrays of 10 random 256-bit integers
-      const numbers1: bigint[] = []
-      const numbers2: bigint[] = []
-      const expectedResults: bigint[] = []
-
-      for (let i = 0; i < 1; i++) {
-        // Generate random 256-bit integers
-        const num1 = generateRandomNumber(32)
-        const num2 = i % 2 === 0 ? generateRandomNumber(32) : num1
-        
-        numbers1.push(num1)
-        numbers2.push(num2)
-        expectedResults.push(num1 >= num2 ? num1 : num2)
-      }
-
-      // Call maxTest with the arrays
-      await (await extendedComparisonTests.maxTest(numbers1, numbers2)).wait()
-
-      // Verify results
-      for (let i = 0; i < 1; i++) {
-        const result = await extendedComparisonTests.uintResults2(i)
-        expect(result).to.equal(expectedResults[i])
-      }
-    })
-  })
-})