@coti-io/coti-contracts 1.1.0 → 1.2.0

package/test/utils/mpc/Mux256.test.ts

@@ -0,0 +1,41 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+function buildTest(
+  contractName: string,
+  func: string,
+  resFunc: string,
+  params: (bigint | boolean)[],
+  expectedResult: bigint
+) {
+  it(`${contractName}.${func}(${params}) 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)(...params, { 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)
+  })
+}
+
+const bit = false
+const a = BigInt("1000000000000000000")
+const b = BigInt("500000000000000000")
+
+describe("Mux 256-bit", function () {
+  buildTest("Mux256TestsContract", "muxTest", "getMuxResult", [bit, a, b], bit ? b : a)
+})
+

package/test/utils/mpc/NegativeCases.test.ts

@@ -0,0 +1,478 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+describe("Negative Test Cases - 8/16/32/64-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 for 8-bit (may revert or return special value)", async function () {
+      this.timeout(60000) // 1 minute timeout
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("MiscellaneousTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = 10
+      const b = 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()
+        expect(receipt?.status).to.equal(1)
+        
+        // If it doesn't revert, check what value it returns
+        const result = await contract.getDivResult()
+        console.log(`Division by zero (8-bit) returned: ${result}`)
+        // Note: MPC precompile may handle division by zero differently for smaller bit sizes
+        // 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 (8-bit) correctly reverted")
+        } else {
+          throw error
+        }
+      }
+    })
+
+    it("Should handle remainder by zero for 8-bit (returns dividend)", async function () {
+      this.timeout(60000) // 1 minute timeout
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("MiscellaneousTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = 10
+      const b = 0
+
+      // Remainder by zero - MPC precompile returns dividend
+      const tx = await contract.remTest(a, b, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      
+      const result = await contract.getRemResult()
+      console.log(`Remainder by zero (8-bit) returned: ${result}`)
+      // MPC precompile returns dividend for remainder by zero
+      expect(result).to.equal(a)
+    })
+  })
+
+  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 for 8-bit with max values", async function () {
+      this.timeout(180000) // 3 minutes for this specific test
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("CheckedArithmeticWithOverflowBitTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test with values that will overflow for 8-bit
+      const nearMax8 = 200  // Close to max uint8 (255)
+      const large = 100     // Will overflow when added (200 + 100 = 300 > 255)
+
+      // This should succeed but overflow bit should be set
+      try {
+        const tx = await contract.checkedAddWithOverflowBitTest(nearMax8, large, { gasLimit })
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+
+        // Note: The contract doesn't expose overflow bit, but we can check the result
+        const result = await contract.getAddResult()
+        console.log(`CheckedAdd result (8-bit): ${result}, expected overflow`)
+        // Result should be wrapped value: (200 + 100) % 256 = 44
+        expect(result).to.equal((nearMax8 + large) % 256)
+      } catch (error: any) {
+        // Some overflow cases may revert
+        if (error.message && error.message.includes("revert")) {
+          console.log("CheckedAdd overflow correctly caused revert")
+        } else {
+          throw error
+        }
+      }
+    })
+
+    it("Should detect underflow in checkedSub for 8-bit", async function () {
+      this.timeout(180000) // 3 minutes for this specific test
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("CheckedArithmeticWithOverflowBitTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test subtraction that would underflow
+      const small = 5
+      const large = 100
+
+      // This should succeed but overflow bit should be set (indicating underflow)
+      try {
+        const tx = await contract.checkedSubWithOverflowBitTest(small, large, { gasLimit })
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+
+        // Check result
+        const result = await contract.getSubResult()
+        console.log(`CheckedSub result (8-bit): ${result}, expected underflow`)
+        // Result should be wrapped value: (5 - 100) % 256 = 161
+        expect(result).to.equal((small - large + 256) % 256)
+      } catch (error: any) {
+        // Some underflow cases may revert
+        if (error.message && error.message.includes("revert")) {
+          console.log("CheckedSub underflow correctly caused revert")
+        } else {
+          throw error
+        }
+      }
+    })
+
+    it("Should detect overflow in checkedMul for 8-bit with large values", async function () {
+      this.timeout(180000) // 3 minutes for this specific test
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("CheckedArithmeticWithOverflowBitTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test multiplication that will overflow
+      const large1 = 20   // 20 * 20 = 400 > 255, will overflow
+      const large2 = 20
+
+      try {
+        const tx = await contract.checkedMulWithOverflowBitTest(large1, large2, { gasLimit })
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+
+        // Check result
+        const result = await contract.getMulResult()
+        console.log(`CheckedMul result (8-bit): ${result}, expected overflow`)
+        // Result should be wrapped value: (20 * 20) % 256 = 144
+        expect(result).to.equal((large1 * large2) % 256)
+      } catch (error: any) {
+        // Some overflow cases may revert
+        if (error.message && error.message.includes("revert")) {
+          console.log("CheckedMul overflow correctly caused revert")
+        } else {
+          throw error
+        }
+      }
+    })
+  })
+
+  describe("Invalid Shift Operations", function () {
+    it("Should handle shift amount >= 8 bits", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("ShiftTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = 10
+      const shift8 = 8   // Equal to 8-bit size
+      const shift16 = 16 // Greater than 8-bit size
+
+      // Shift by 8 (equal to bit size) - behavior depends on MPC precompile
+      // For 8-bit: 10 << 8 = 2560, but since it's uint8, it wraps to 0
+      // However, the contract tests all bit sizes, so 16/32/64-bit results may not be 0
+      const tx1 = await contract.shlTest(a, shift8, { gasLimit })
+      const receipt1 = await tx1.wait()
+      expect(receipt1?.status).to.equal(1)
+      const results1 = await contract.getAllShiftResults()
+      console.log(`Shift by 8 returned: 8-bit=${results1[0]}, 16-bit=${results1[1]}, 32-bit=${results1[2]}, 64-bit=${results1[3]}`)
+      // 8-bit should be 0 (wrapped), others may have actual shifted values
+      expect(results1[0]).to.equal(0)  // 8-bit: all bits shifted out (wrapped)
+
+      // Shift by 16 (greater than 8-bit size) - behavior depends on MPC precompile
+      const tx2 = await contract.shlTest(a, shift16, { gasLimit })
+      const receipt2 = await tx2.wait()
+      expect(receipt2?.status).to.equal(1)
+      const results2 = await contract.getAllShiftResults()
+      console.log(`Shift by 16 returned: 8-bit=${results2[0]}, 16-bit=${results2[1]}, 32-bit=${results2[2]}, 64-bit=${results2[3]}`)
+      // 8-bit should be 0, others may have wrapped values
+      expect(results2[0]).to.equal(0)  // 8-bit: all bits shifted out
+    })
+
+    it("Should handle right shift by >= 8 bits", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("ShiftTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = 10
+      const shift8 = 8
+
+      // Right shift by 8 - should result in 0
+      const tx = await contract.shrTest(a, shift8, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      const result = await contract.getResult()
+      expect(result).to.equal(0)  // All bits shifted out
+    })
+
+    it("Should handle shift amount >= 16 bits", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("ShiftTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = 10
+      const shift16 = 16  // Equal to 16-bit size
+      const shift32 = 32  // Greater than 16-bit size
+
+      // Shift by 16 - should result in 0 for 16-bit
+      const tx1 = await contract.shlTest(a, shift16, { gasLimit })
+      const receipt1 = await tx1.wait()
+      expect(receipt1?.status).to.equal(1)
+      const results1 = await contract.getAllShiftResults()
+      expect(results1[1]).to.equal(0)  // 16-bit: all bits shifted out
+
+      // Shift by 32 - should result in 0 for 32-bit
+      const tx2 = await contract.shlTest(a, shift32, { gasLimit })
+      const receipt2 = await tx2.wait()
+      expect(receipt2?.status).to.equal(1)
+      const results2 = await contract.getAllShiftResults()
+      expect(results2[2]).to.equal(0)  // 32-bit: all bits shifted out
+    })
+
+    it("Should handle shift amount >= 64 bits", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("ShiftTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = 10
+      const shift64 = 64  // Equal to 64-bit size (but uint8 max is 255, so we use 64)
+
+      // Shift by 64 - should result in 0 for 64-bit
+      const tx = await contract.shlTest(a, shift64, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+      const results = await contract.getAllShiftResults()
+      expect(results[3]).to.equal(0)  // 64-bit: all bits shifted out
+    })
+  })
+
+  describe("Transfer with Insufficient Balance", function () {
+    it("Should handle transfer when balance < amount for 8-bit", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("TransferTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const smallBalance = 10
+      const largeAmount = 100  // 10x balance
+
+      // Transfer more than available balance
+      try {
+        const tx = await contract.transferTest(smallBalance, 0, largeAmount, { gasLimit })
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+        
+        // Check the result flag
+        const results = await contract.getResults()
+        console.log(`Transfer result (8-bit): new_a=${results[0]}, new_b=${results[1]}, success=${results[2]}`)
+        
+        // The behavior depends on MPC precompile implementation
+        // If transfer fails, success flag should be false
+        // Or the new balance might be wrapped/underflowed
+        if (results[2] === false) {
+          console.log("✅ Transfer correctly returned failure flag for insufficient balance")
+        } else {
+          console.log("⚠️ Transfer succeeded despite insufficient balance - may allow underflow")
+          // If it allows underflow, check wrapped value
+          expect(results[0]).to.equal((smallBalance - largeAmount + 256) % 256)
+        }
+      } catch (error: any) {
+        // Reverting is acceptable behavior for insufficient balance
+        if (error.message && error.message.includes("revert")) {
+          console.log("✅ Insufficient balance correctly caused revert")
+        } else {
+          throw error
+        }
+      }
+    })
+
+    it("Should handle transfer with zero balance", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("TransferTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const zeroBalance = 0
+      const amount = 10
+
+      try {
+        const tx = await contract.transferTest(zeroBalance, 0, amount, { gasLimit })
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+        
+        const results = await contract.getResults()
+        console.log(`Transfer from zero balance (8-bit): new_a=${results[0]}, new_b=${results[1]}, success=${results[2]}`)
+        
+        if (results[2] === false) {
+          console.log("✅ Transfer correctly returned failure flag for zero balance")
+        }
+      } catch (error: any) {
+        if (error.message && error.message.includes("revert")) {
+          console.log("✅ Zero balance transfer correctly caused revert")
+        } else {
+          throw error
+        }
+      }
+    })
+  })
+
+  describe("Transfer with Insufficient Allowance", function () {
+    it("Should handle transferWithAllowance when allowance < amount", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("TransferWithAllowanceTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const balance = 100
+      const smallAllowance = 10   // Small allowance
+      const largeAmount = 100     // 10x allowance
+
+      // Transfer more than allowance
+      try {
+        const tx = await contract.transferWithAllowanceTest(
+          balance, 
+          0, 
+          largeAmount, 
+          smallAllowance, 
+          { gasLimit }
+        )
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+        
+        const results = await contract.getResults()
+        console.log(`TransferWithAllowance result (8-bit): new_a=${results[0]}, new_b=${results[1]}, success=${results[2]}, new_allowance=${results[3]}`)
+        
+        // Check if allowance was properly enforced
+        // The new_allowance should not be negative if enforcement works
+        if (results[2] === false) {
+          console.log("✅ TransferWithAllowance correctly returned failure flag for insufficient allowance")
+        } else {
+          console.log("⚠️ TransferWithAllowance succeeded despite insufficient allowance")
+        }
+      } catch (error: any) {
+        if (error.message && error.message.includes("revert")) {
+          console.log("✅ Insufficient allowance correctly caused revert")
+        } else {
+          throw error
+        }
+      }
+    })
+
+    it("Should handle transferWithAllowance with zero allowance", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("TransferWithAllowanceTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const balance = 100
+      const zeroAllowance = 0
+      const amount = 10
+
+      try {
+        const tx = await contract.transferWithAllowanceTest(
+          balance,
+          0,
+          amount,
+          zeroAllowance,
+          { gasLimit }
+        )
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+        
+        const results = await contract.getResults()
+        console.log(`TransferWithAllowance with zero allowance (8-bit): success=${results[2]}, new_allowance=${results[3]}`)
+        
+        if (results[2] === false) {
+          console.log("✅ TransferWithAllowance correctly returned failure flag for zero allowance")
+        }
+      } catch (error: any) {
+        if (error.message && error.message.includes("revert")) {
+          console.log("✅ Zero allowance transfer correctly caused revert")
+        } else {
+          throw error
+        }
+      }
+    })
+  })
+
+  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("ArithmeticTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const a = 10
+      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(0)
+    })
+
+    it("Should handle max value operations for 8-bit", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("ArithmeticTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const max8 = 255  // Max uint8
+      const zero = 0
+
+      // Max + 0 should work
+      const tx = await contract.addTest(max8, zero, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      const result = await contract.getAddResult()
+      expect(result).to.equal(max8)
+    })
+
+    it("Should handle max value operations for 16-bit", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("ArithmeticTestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      // Test with values that will be cast to 16-bit
+      const a = 10
+      const b = 5
+
+      // Operations should work across all bit sizes
+      const tx = await contract.addTest(a, b, { gasLimit })
+      const receipt = await tx.wait()
+      expect(receipt?.status).to.equal(1)
+
+      const result = await contract.getAddResult()
+      expect(result).to.equal(a + b)
+    })
+  })
+})
+