@coti-io/coti-contracts 1.0.9 → 1.2.0

package/test/utils/mpc/NegativeCases128.test.ts

@@ -0,0 +1,237 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+describe("Negative Test Cases - 128-bit", function () {
+  // Increase timeout for MPC operations, especially overflow detection
+  this.timeout(300000) // 5 minutes
+
+  describe("Division by Zero", function () {
+    it("Should handle division by zero (may revert or return special value)", async function () {
+      this.timeout(60000) // 1 minute timeout
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Arithmetic128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const b = BigInt(0)
+
+      // Division by zero - check if it reverts or returns a value
+      try {
+        const tx = await contract.divTest(a, b, { gasLimit })
+        const receipt = await tx.wait()
+        
+        // If it doesn't revert, check what value it returns
+        const result = await contract.getDivResult()
+        console.log(`Division by zero returned: ${result}`)
+        // Note: MPC precompile may handle division by zero differently
+        // It might return 0, max value, or some other special value
+      } catch (error: any) {
+        // If it reverts, that's also valid behavior
+        if (error.message && error.message.includes("revert")) {
+          console.log("Division by zero correctly reverted")
+        } else {
+          throw error
+        }
+      }
+    })
+
+    it("Should handle remainder by zero (may revert or return special value)", async function () {
+      this.timeout(60000) // 1 minute timeout
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Arithmetic128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const b = BigInt(0)
+
+      // Remainder by zero - check if it reverts or returns a value
+      try {
+        const tx = await contract.remTest(a, b, { gasLimit })
+        const receipt = await tx.wait()
+        
+        // If it doesn't revert, check what value it returns
+        const result = await contract.getRemResult()
+        console.log(`Remainder by zero returned: ${result}`)
+        // Note: MPC precompile may handle remainder by zero differently
+      } catch (error: any) {
+        // If it reverts, that's also valid behavior
+        if (error.message && error.message.includes("revert")) {
+          console.log("Remainder by zero correctly reverted")
+        } else {
+          throw error
+        }
+      }
+    })
+  })
+
+  describe("Arithmetic Overflow - Checked Operations", function () {
+    // Note: Overflow detection tests are computationally expensive due to MPC operations
+    // These tests may take 1-3 minutes each to complete
+    
+    it("Should detect overflow in checkedAdd with max values", async function () {
+      this.timeout(180000) // 3 minutes for this specific test
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("CheckedArithmetic128WithOverflowBitTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test with values that will overflow
+      // Using smaller values to reduce computation time while still testing overflow
+      const nearMax128 = (BigInt(1) << BigInt(127))  // 2^127 (half of max)
+      const large = (BigInt(1) << BigInt(127)) + BigInt(1)  // Will overflow when added
+
+      // This should succeed but overflow bit should be set
+      const tx = await contract.checkedAddWithOverflowBitTest(nearMax128, large, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      // Check overflow bit
+      const overflowBit = await contract.getOverflowBit()
+      // Note: The actual behavior depends on the MPC precompile implementation
+      // If overflow is detected, overflowBit should be true
+      console.log(`Overflow bit detected: ${overflowBit}`)
+    })
+
+    it("Should detect underflow in checkedSub", async function () {
+      this.timeout(180000) // 3 minutes for this specific test
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("CheckedArithmetic128WithOverflowBitTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test subtraction that would underflow
+      const small = BigInt(5)
+      const large = BigInt("1000000000000000000")
+
+      // This should succeed but overflow bit should be set (indicating underflow)
+      const tx = await contract.checkedSubWithOverflowBitTest(small, large, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      // Check overflow bit
+      const overflowBit = await contract.getOverflowBit()
+      // If underflow is detected, overflowBit should be true
+      console.log(`Underflow bit detected: ${overflowBit}`)
+    })
+
+    it("Should detect overflow in checkedMul with large values", async function () {
+      this.timeout(180000) // 3 minutes for this specific test
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("CheckedArithmetic128WithOverflowBitTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test multiplication that will overflow
+      // Using smaller values to reduce computation time while still testing overflow
+      const large1 = BigInt(1) << BigInt(80)   // 2^80
+      const large2 = BigInt(1) << BigInt(70)   // 2^70
+      // 2^80 * 2^70 = 2^150 > 2^128, will overflow
+
+      const tx = await contract.checkedMulWithOverflowBitTest(large1, large2, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      // Check overflow bit
+      const overflowBit = await contract.getOverflowBit()
+      console.log(`Multiplication overflow bit detected: ${overflowBit}`)
+    })
+  })
+
+  describe("Edge Cases - Boundary Values", function () {
+    it("Should handle subtraction resulting in zero", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Arithmetic128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const b = a  // Same value
+
+      const tx = await contract.subTest(a, b, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      const result = await contract.getSubResult()
+      expect(result).to.equal(BigInt(0))
+    })
+
+    it("Should handle max value operations", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Arithmetic128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const max128 = (BigInt(1) << BigInt(128)) - BigInt(1)
+      const zero = BigInt(0)
+
+      // Max + 0 should work
+      const tx = await contract.addTest(max128, zero, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      const result = await contract.getAddResult()
+      expect(result).to.equal(max128)
+    })
+  })
+
+  describe("Invalid Shift Operations", function () {
+    it("Should handle shift amount >= 128 bits", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Shift128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const shift128 = 128  // Equal to bit size
+      const shift129 = 129  // Greater than bit size (but uint8 max is 255, so this is valid)
+
+      // Shift by 128 (equal to bit size) - should work but result will be 0
+      const tx1 = await contract.shlTest(a, shift128, { gasLimit })
+      const receipt1 = await tx1.wait()
+      expect(receipt1?.status).to.equal(1)
+      const result1 = await contract.getShlResult()
+      expect(result1).to.equal(BigInt(0))  // All bits shifted out
+
+      // Shift by 129 (greater than bit size) - behavior depends on MPC precompile
+      const tx2 = await contract.shlTest(a, shift129, { gasLimit })
+      const receipt2 = await tx2.wait()
+      expect(receipt2?.status).to.equal(1)
+      const result2 = await contract.getShlResult()
+      // Result should be 0 or wrapped value depending on precompile behavior
+      console.log(`Shift by 129 returned: ${result2}`)
+      expect(result2).to.equal(BigInt(0))  // All bits shifted out
+    })
+
+    it("Should handle right shift by >= 128 bits", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Shift128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const shift128 = 128
+
+      // Right shift by 128 - should result in 0
+      const tx = await contract.shrTest(a, shift128, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      const result = await contract.getShrResult()
+      expect(result).to.equal(BigInt(0))  // All bits shifted out
+    })
+  })
+})
+

package/test/utils/mpc/NegativeCases256.test.ts

@@ -0,0 +1,236 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+describe("Negative Test Cases - 256-bit", function () {
+  // Increase timeout for MPC operations, especially overflow detection
+  this.timeout(300000) // 5 minutes
+
+  describe("Division by Zero", function () {
+    it("Should handle division by zero (may revert or return special value)", async function () {
+      this.timeout(60000) // 1 minute timeout
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Arithmetic256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const b = BigInt(0)
+
+      // Division by zero - check if it reverts or returns a value
+      try {
+        const tx = await contract.divTest(a, b, { gasLimit })
+        const receipt = await tx.wait()
+        
+        // If it doesn't revert, check what value it returns
+        const result = await contract.getDivResult()
+        console.log(`Division by zero returned: ${result}`)
+        // Note: MPC precompile may handle division by zero differently
+        // It might return 0, max value, or some other special value
+      } catch (error: any) {
+        // If it reverts, that's also valid behavior
+        if (error.message && error.message.includes("revert")) {
+          console.log("Division by zero correctly reverted")
+        } else {
+          throw error
+        }
+      }
+    })
+
+    it("Should handle remainder by zero (may revert or return special value)", async function () {
+      this.timeout(60000) // 1 minute timeout
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Arithmetic256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const b = BigInt(0)
+
+      // Remainder by zero - check if it reverts or returns a value
+      try {
+        const tx = await contract.remTest(a, b, { gasLimit })
+        const receipt = await tx.wait()
+        
+        // If it doesn't revert, check what value it returns
+        const result = await contract.getRemResult()
+        console.log(`Remainder by zero returned: ${result}`)
+        // Note: MPC precompile may handle remainder by zero differently
+      } catch (error: any) {
+        // If it reverts, that's also valid behavior
+        if (error.message && error.message.includes("revert")) {
+          console.log("Remainder by zero correctly reverted")
+        } else {
+          throw error
+        }
+      }
+    })
+  })
+
+  describe("Arithmetic Overflow - Checked Operations", function () {
+    // Note: Overflow detection tests are computationally expensive due to MPC operations
+    // These tests may take 1-3 minutes each to complete
+    
+    it("Should detect overflow in checkedAdd with max values", async function () {
+      this.timeout(180000) // 3 minutes for this specific test
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("CheckedArithmetic256WithOverflowBitTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test with values that will overflow
+      // Using smaller values to reduce computation time while still testing overflow
+      const nearMax256 = (BigInt(1) << BigInt(255))  // 2^255 (half of max)
+      const large = (BigInt(1) << BigInt(255)) + BigInt(1)  // Will overflow when added
+
+      // This should succeed but overflow bit should be set
+      const tx = await contract.checkedAddWithOverflowBitTest(nearMax256, large, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      // Check overflow bit
+      const overflowBit = await contract.getOverflowBit()
+      // Note: The actual behavior depends on the MPC precompile implementation
+      // If overflow is detected, overflowBit should be true
+      console.log(`Overflow bit detected: ${overflowBit}`)
+    })
+
+    it("Should detect underflow in checkedSub", async function () {
+      this.timeout(180000) // 3 minutes for this specific test
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("CheckedArithmetic256WithOverflowBitTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test subtraction that would underflow
+      const small = BigInt(5)
+      const large = BigInt("1000000000000000000")
+
+      // This should succeed but overflow bit should be set (indicating underflow)
+      const tx = await contract.checkedSubWithOverflowBitTest(small, large, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      // Check overflow bit
+      const overflowBit = await contract.getOverflowBit()
+      // If underflow is detected, overflowBit should be true
+      console.log(`Underflow bit detected: ${overflowBit}`)
+    })
+
+    it("Should detect overflow in checkedMul with large values", async function () {
+      this.timeout(180000) // 3 minutes for this specific test
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("CheckedArithmetic256WithOverflowBitTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test multiplication that will overflow
+      // Using smaller values to reduce computation time while still testing overflow
+      const large1 = BigInt(1) << BigInt(150)  // 2^150
+      const large2 = BigInt(1) << BigInt(150)  // 2^150
+      // 2^150 * 2^150 = 2^300 > 2^256, will overflow
+
+      const tx = await contract.checkedMulWithOverflowBitTest(large1, large2, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      // Check overflow bit
+      const overflowBit = await contract.getOverflowBit()
+      console.log(`Multiplication overflow bit detected: ${overflowBit}`)
+    })
+  })
+
+  describe("Edge Cases - Boundary Values", function () {
+    it("Should handle subtraction resulting in zero", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Arithmetic256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const b = a  // Same value
+
+      const tx = await contract.subTest(a, b, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      const result = await contract.getSubResult()
+      expect(result).to.equal(BigInt(0))
+    })
+
+    it("Should handle max value operations", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Arithmetic256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const max256 = (BigInt(1) << BigInt(256)) - BigInt(1)
+      const zero = BigInt(0)
+
+      // Max + 0 should work
+      const tx = await contract.addTest(max256, zero, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      const result = await contract.getAddResult()
+      expect(result).to.equal(max256)
+    })
+  })
+
+  describe("Invalid Shift Operations", function () {
+    it("Should handle shift amount >= 256 bits", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Shift256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const shift256 = 255  // uint8 max is 255, so we test with max possible
+      const shift200 = 200  // Large shift value
+
+      // Shift by 200 - should work but most bits shifted out
+      const tx1 = await contract.shlTest(a, shift200, { gasLimit })
+      const receipt1 = await tx1.wait()
+      expect(receipt1?.status).to.equal(1)
+      const result1 = await contract.getShlResult()
+      console.log(`Shift by 200 returned: ${result1}`)
+
+      // Shift by 255 (max uint8) - behavior depends on MPC precompile
+      const tx2 = await contract.shlTest(a, shift256, { gasLimit })
+      const receipt2 = await tx2.wait()
+      expect(receipt2?.status).to.equal(1)
+      const result2 = await contract.getShlResult()
+      console.log(`Shift by 255 returned: ${result2}`)
+      // Result should be 0 or wrapped value depending on precompile behavior
+    })
+
+    it("Should handle right shift by large amounts", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Shift256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = BigInt("1000000000000000000")
+      const shift255 = 255  // Max uint8
+
+      // Right shift by 255 - should result in 0
+      const tx = await contract.shrTest(a, shift255, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      const result = await contract.getShrResult()
+      expect(result).to.equal(BigInt(0))  // All bits shifted out
+    })
+  })
+})
+

package/test/utils/mpc/OnBoard128.test.ts

@@ -0,0 +1,90 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+function buildTest(
+  contractName: string,
+  func: string,
+  resFunc: string,
+  param: bigint,
+  expectedResult: bigint
+) {
+  it(`${contractName}.${func}(${param}) should return ${expectedResult}`, async function () {
+    const [owner] = await setupAccounts()
+    const provider = owner.provider!
+
+    const factory = await hre.ethers.getContractFactory(contractName, owner as any)
+    const contract = await factory.deploy({ gasLimit })
+    await contract.waitForDeployment()
+
+    const tx = await contract.getFunction(func)(param, { gasLimit })
+    const receipt = await tx.wait()
+    
+    const result = await contract.getFunction(resFunc)()
+    expect(result).to.equal(expectedResult)
+    
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.status).to.equal(1)
+  })
+}
+
+// Test values
+const MASK_128 = (BigInt(1) << BigInt(128)) - BigInt(1)
+const HALF_MAX_128 = BigInt(1) << BigInt(127)
+const testValue1 = BigInt("1000000000000000000")
+const testValue2 = BigInt("500000000000000000")
+const testValue3 = BigInt("2000000000000000000")
+
+describe("OnBoard 128-bit", function () {
+  describe("Round-trip tests (setPublic -> offBoard -> onBoard -> decrypt)", function () {
+    buildTest("OnBoard128TestsContract", "testOnBoardOffBoardRoundTrip", "getOnboardOffboardResult", testValue1, testValue1)
+    buildTest("OnBoard128TestsContract", "testOnBoardOffBoardRoundTrip", "getOnboardOffboardResult", testValue2, testValue2)
+    buildTest("OnBoard128TestsContract", "testOnBoardOffBoardRoundTrip", "getOnboardOffboardResult", HALF_MAX_128, HALF_MAX_128)
+  })
+
+  describe("Multiple values test", function () {
+    it("OnBoard128TestsContract.testOnBoardMultipleValues should handle multiple values", async function () {
+      const [owner] = await setupAccounts()
+      const provider = owner.provider!
+
+      const factory = await hre.ethers.getContractFactory("OnBoard128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Execute the transaction - the contract's require statements verify correctness
+      // If the transaction succeeds, all three values were correctly processed
+      const tx = await contract.testOnBoardMultipleValues(testValue1, testValue2, testValue3, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      
+      const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+      expect(txFromChain).to.not.be.null
+      expect(txFromChain?.status).to.equal(1)
+    })
+  })
+
+  describe("Edge cases (zero and max)", function () {
+    it("OnBoard128TestsContract.testOnBoardEdgeCases should handle zero and max values", async function () {
+      const [owner] = await setupAccounts()
+      const provider = owner.provider!
+
+      const factory = await hre.ethers.getContractFactory("OnBoard128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Execute the transaction - the contract's require statements verify correctness
+      // If the transaction succeeds, both zero and max values were correctly processed
+      const tx = await contract.testOnBoardEdgeCases({ gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      
+      const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+      expect(txFromChain).to.not.be.null
+      expect(txFromChain?.status).to.equal(1)
+    })
+  })
+})
+

package/test/utils/mpc/OnBoard256.test.ts

@@ -0,0 +1,114 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+function buildTest(
+  contractName: string,
+  func: string,
+  resFunc: string,
+  param: bigint,
+  expectedResult: bigint
+) {
+  it(`${contractName}.${func}(${param}) should return ${expectedResult}`, async function () {
+    const [owner] = await setupAccounts()
+    const provider = owner.provider!
+
+    const factory = await hre.ethers.getContractFactory(contractName, owner as any)
+    const contract = await factory.deploy({ gasLimit })
+    await contract.waitForDeployment()
+
+    const tx = await contract.getFunction(func)(param, { gasLimit })
+    const receipt = await tx.wait()
+    
+    const result = await contract.getFunction(resFunc)()
+    expect(result).to.equal(expectedResult)
+    
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.status).to.equal(1)
+  })
+}
+
+// Test values
+const MASK_256 = (BigInt(1) << BigInt(256)) - BigInt(1)
+const HALF_MAX_256 = BigInt(1) << BigInt(255)
+const testValue1 = BigInt("1000000000000000000")
+const testValue2 = BigInt("500000000000000000")
+const testValue3 = BigInt("2000000000000000000")
+const valueAbove128 = BigInt(1) << BigInt(128)  // 2^128
+const valueBelow128 = (BigInt(1) << BigInt(127)) - BigInt(1)  // 2^127 - 1
+
+describe("OnBoard 256-bit", function () {
+  describe("Round-trip tests (setPublic -> offBoard -> onBoard -> decrypt)", function () {
+    buildTest("OnBoard256TestsContract", "testOnBoardOffBoardRoundTrip", "getOnboardOffboardResult", testValue1, testValue1)
+    buildTest("OnBoard256TestsContract", "testOnBoardOffBoardRoundTrip", "getOnboardOffboardResult", testValue2, testValue2)
+    buildTest("OnBoard256TestsContract", "testOnBoardOffBoardRoundTrip", "getOnboardOffboardResult", HALF_MAX_256, HALF_MAX_256)
+    buildTest("OnBoard256TestsContract", "testOnBoardOffBoardRoundTrip", "getOnboardOffboardResult", valueAbove128, valueAbove128)
+  })
+
+  describe("Multiple values test", function () {
+    it("OnBoard256TestsContract.testOnBoardMultipleValues should handle multiple values", async function () {
+      const [owner] = await setupAccounts()
+      const provider = owner.provider!
+
+      const factory = await hre.ethers.getContractFactory("OnBoard256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Execute the transaction - the contract's require statements verify correctness
+      // If the transaction succeeds, all three values were correctly processed
+      const tx = await contract.testOnBoardMultipleValues(testValue1, testValue2, testValue3, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      
+      const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+      expect(txFromChain).to.not.be.null
+      expect(txFromChain?.status).to.equal(1)
+    })
+  })
+
+  describe("Edge cases (zero and max)", function () {
+    it("OnBoard256TestsContract.testOnBoardEdgeCases should handle zero and max values", async function () {
+      const [owner] = await setupAccounts()
+      const provider = owner.provider!
+
+      const factory = await hre.ethers.getContractFactory("OnBoard256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Execute the transaction - the contract's require statements verify correctness
+      // If the transaction succeeds, both zero and max values were correctly processed
+      const tx = await contract.testOnBoardEdgeCases({ gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      
+      const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+      expect(txFromChain).to.not.be.null
+      expect(txFromChain?.status).to.equal(1)
+    })
+  })
+
+  describe("128-bit boundary test", function () {
+    it("OnBoard256TestsContract.testOnBoard128BitBoundary should handle values crossing 128-bit boundary", async function () {
+      const [owner] = await setupAccounts()
+      const provider = owner.provider!
+
+      const factory = await hre.ethers.getContractFactory("OnBoard256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Execute the transaction - the contract's require statements verify correctness
+      // If the transaction succeeds, both boundary values were correctly processed
+      const tx = await contract.testOnBoard128BitBoundary({ gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      
+      const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+      expect(txFromChain).to.not.be.null
+      expect(txFromChain?.status).to.equal(1)
+    })
+  })
+})
+