@coti-io/coti-contracts 1.0.9 → 1.2.0

package/test/utils/mpc/InvalidCiphertext256.test.ts

@@ -0,0 +1,201 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { Buffer } from "buffer"
+import { setupAccounts } from "../accounts"
+import { Wallet, itUint256 } from "@coti-io/coti-ethers"
+import { ValidateCiphertext256TestsContract } from "../../../typechain-types"
+
+const GAS_LIMIT = 12000000
+
+async function deploy() {
+    const [owner] = await setupAccounts()
+    const contractFactory = await hre.ethers.getContractFactory("ValidateCiphertext256TestsContract", owner as any)
+    const contract = await contractFactory.deploy({ gasLimit: GAS_LIMIT })
+    await contract.waitForDeployment()
+    return {
+        contract,
+        contractAddress: await contract.getAddress(),
+        owner
+    }
+}
+
+describe("Invalid Ciphertext Validation - 256-bit", function () {
+    this.timeout(120000) // 2 minutes
+    let contract: ValidateCiphertext256TestsContract
+    let contractAddress: string
+    let owner: Wallet
+
+    before(async function () {
+        const deployment = await deploy()
+        contract = deployment.contract
+        contractAddress = deployment.contractAddress
+        owner = deployment.owner
+    })
+
+    describe("Invalid Signature Tests", function () {
+        it("Should reject ciphertext with invalid signature (all zeros)", async function () {
+            // Create valid ciphertext
+            const testValue = (2n ** 128n) + BigInt("1000000000000000000")  // > 128 bits
+            const validItUint = await owner.encryptValue256(
+                testValue,
+                contractAddress,
+                contract.validateAndStore.fragment.selector
+            )
+
+            // Corrupt the signature - convert to Buffer
+            const invalidSignature = Buffer.from("00".repeat(64), "hex")
+            
+            const invalidItUint: itUint256 = {
+                ciphertext: validItUint.ciphertext,
+                signature: invalidSignature
+            }
+
+            // Should revert or return false
+            try {
+                const tx = await contract.validateAndStore(invalidItUint, { gasLimit: GAS_LIMIT })
+                const receipt = await tx.wait()
+                
+                // Check validation result
+                const validationResult = await contract.getValidationResult()
+                expect(validationResult).to.equal(false, "Invalid signature should fail validation")
+                console.log("✅ Invalid signature correctly failed validation")
+            } catch (error: any) {
+                // Reverting is also acceptable behavior
+                if (error.message && error.message.includes("revert")) {
+                    console.log("✅ Invalid signature correctly caused revert")
+                } else {
+                    throw error
+                }
+            }
+        })
+
+        it("Should reject ciphertext with wrong contract address signature", async function () {
+            // Create ciphertext signed for different contract
+            const wrongAddress = "0x" + "11".repeat(20)  // Different address
+            const testValue = (2n ** 128n) + BigInt("1000000000000000000")
+            
+            // This should fail because signature is for wrong address
+            const itUint = await owner.encryptValue256(
+                testValue,
+                wrongAddress,  // Wrong address
+                contract.validateAndStore.fragment.selector
+            )
+
+            // Try to validate with correct contract address
+            try {
+                const tx = await contract.validateAndStore(itUint, { gasLimit: GAS_LIMIT })
+                const receipt = await tx.wait()
+                
+                // Check validation result
+                const validationResult = await contract.getValidationResult()
+                expect(validationResult).to.equal(false, "Wrong address signature should fail")
+                console.log("✅ Wrong address signature correctly failed validation")
+            } catch (error: any) {
+                if (error.message && error.message.includes("revert")) {
+                    console.log("✅ Wrong address signature correctly caused revert")
+                } else {
+                    throw error
+                }
+            }
+        })
+
+        it("Should reject ciphertext with corrupted signature", async function () {
+            const testValue = (2n ** 128n) + BigInt("1000000000000000000")
+            const validItUint = await owner.encryptValue256(
+                testValue,
+                contractAddress,
+                contract.validateAndStore.fragment.selector
+            )
+
+            // Convert signature to Buffer, corrupt it
+            const sigBuffer = Buffer.isBuffer(validItUint.signature) 
+                ? Buffer.from(validItUint.signature)
+                : Buffer.from(validItUint.signature)
+            
+            // Flip first byte
+            sigBuffer[0] = sigBuffer[0] ^ 0xFF
+
+            const corruptedItUint: itUint256 = {
+                ciphertext: validItUint.ciphertext,
+                signature: sigBuffer
+            }
+
+            try {
+                const tx = await contract.validateAndStore(corruptedItUint, { gasLimit: GAS_LIMIT })
+                const receipt = await tx.wait()
+                
+                const validationResult = await contract.getValidationResult()
+                expect(validationResult).to.equal(false, "Corrupted signature should fail")
+                console.log("✅ Corrupted signature correctly failed validation")
+            } catch (error: any) {
+                if (error.message && error.message.includes("revert")) {
+                    console.log("✅ Corrupted signature correctly caused revert")
+                } else {
+                    throw error
+                }
+            }
+        })
+    })
+
+    describe("Corrupted Ciphertext Tests", function () {
+        it("Should handle corrupted ciphertext data", async function () {
+            const testValue = (2n ** 128n) + BigInt("1000000000000000000")
+            const validItUint = await owner.encryptValue256(
+                testValue,
+                contractAddress,
+                contract.validateAndStore.fragment.selector
+            )
+
+            // Corrupt the ciphertext by modifying high or low parts
+            const corruptedItUint: itUint256 = {
+                ciphertext: {
+                    ciphertextHigh: (BigInt(validItUint.ciphertext.ciphertextHigh) ^ BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).toString(),
+                    ciphertextLow: validItUint.ciphertext.ciphertextLow
+                },
+                signature: validItUint.signature
+            }
+
+            // Should fail validation
+            try {
+                const tx = await contract.validateAndStore(corruptedItUint, { gasLimit: GAS_LIMIT })
+                const receipt = await tx.wait()
+                
+                const validationResult = await contract.getValidationResult()
+                expect(validationResult).to.equal(false, "Corrupted ciphertext should fail validation")
+                console.log("✅ Corrupted ciphertext correctly failed validation")
+            } catch (error: any) {
+                if (error.message && error.message.includes("revert")) {
+                    console.log("✅ Corrupted ciphertext correctly caused revert")
+                } else {
+                    throw error
+                }
+            }
+        })
+
+        it("Should handle empty ciphertext", async function () {
+            const emptyItUint: itUint256 = {
+                ciphertext: {
+                    ciphertextHigh: "0",
+                    ciphertextLow: "0"
+                },
+                signature: Buffer.from("00".repeat(64), "hex")
+            }
+
+            try {
+                const tx = await contract.validateAndStore(emptyItUint, { gasLimit: GAS_LIMIT })
+                const receipt = await tx.wait()
+                
+                const validationResult = await contract.getValidationResult()
+                expect(validationResult).to.equal(false, "Empty ciphertext should fail validation")
+                console.log("✅ Empty ciphertext correctly failed validation")
+            } catch (error: any) {
+                if (error.message && error.message.includes("revert")) {
+                    console.log("✅ Empty ciphertext correctly caused revert")
+                } else {
+                    throw error
+                }
+            }
+        })
+    })
+})
+

package/test/utils/mpc/InvalidTransfer128.test.ts

@@ -0,0 +1,166 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+describe("Invalid Transfer Operations - 128-bit", function () {
+  this.timeout(120000) // 2 minutes
+
+  describe("Transfer with Insufficient Balance", function () {
+    it("Should handle transfer when balance < amount", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Transfer128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const smallBalance = BigInt("100000000000000000")   // 0.1
+      const largeAmount = BigInt("1000000000000000000")  // 1.0 (10x balance)
+
+      // Transfer more than available balance
+      // Note: MPC precompile may handle this differently - it might:
+      // 1. Revert the transaction
+      // 2. Return a failure flag (result = false)
+      // 3. Allow underflow (result in wrapped value)
+      
+      try {
+        const tx = await contract.transferTest(smallBalance, BigInt(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: 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")
+        }
+      } 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("Transfer128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const zeroBalance = BigInt(0)
+      const amount = BigInt("100000000000000000")
+
+      try {
+        const tx = await contract.transferTest(zeroBalance, BigInt(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: 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("TransferWithAllowance128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const balance = BigInt("1000000000000000000")
+      const smallAllowance = BigInt("100000000000000000")   // 0.1
+      const largeAmount = BigInt("1000000000000000000")     // 1.0 (10x allowance)
+
+      // Transfer more than allowance
+      try {
+        const tx = await contract.transferWithAllowanceTest(
+          balance, 
+          BigInt(0), 
+          largeAmount, 
+          smallAllowance, 
+          { gasLimit }
+        )
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+        
+        const results = await contract.getResults()
+        console.log(`TransferWithAllowance result: 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("TransferWithAllowance128TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const balance = BigInt("1000000000000000000")
+      const zeroAllowance = BigInt(0)
+      const amount = BigInt("100000000000000000")
+
+      try {
+        const tx = await contract.transferWithAllowanceTest(
+          balance,
+          BigInt(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: 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
+        }
+      }
+    })
+  })
+})
+

package/test/utils/mpc/InvalidTransfer256.test.ts

@@ -0,0 +1,158 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+describe("Invalid Transfer Operations - 256-bit", function () {
+  this.timeout(120000) // 2 minutes
+
+  describe("Transfer with Insufficient Balance", function () {
+    it("Should handle transfer when balance < amount", async function () {
+      const [owner] = await setupAccounts()
+
+      const factory = await hre.ethers.getContractFactory("Transfer256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const smallBalance = BigInt("100000000000000000")   // 0.1
+      const largeAmount = BigInt("1000000000000000000")  // 1.0 (10x balance)
+
+      // Transfer more than available balance
+      try {
+        const tx = await contract.transferTest(smallBalance, BigInt(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: new_a=${results[0]}, new_b=${results[1]}, success=${results[2]}`)
+        
+        // The behavior depends on MPC precompile implementation
+        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")
+        }
+      } 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("Transfer256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const zeroBalance = BigInt(0)
+      const amount = BigInt("100000000000000000")
+
+      try {
+        const tx = await contract.transferTest(zeroBalance, BigInt(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: 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("TransferWithAllowance256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const balance = BigInt("1000000000000000000")
+      const smallAllowance = BigInt("100000000000000000")   // 0.1
+      const largeAmount = BigInt("1000000000000000000")     // 1.0 (10x allowance)
+
+      // Transfer more than allowance
+      try {
+        const tx = await contract.transferWithAllowanceTest(
+          balance, 
+          BigInt(0), 
+          largeAmount, 
+          smallAllowance, 
+          { gasLimit }
+        )
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+        
+        const results = await contract.getResults()
+        console.log(`TransferWithAllowance result: new_a=${results[0]}, new_b=${results[1]}, success=${results[2]}, new_allowance=${results[3]}`)
+        
+        // Check if allowance was properly enforced
+        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("TransferWithAllowance256TestsContract", owner as any)
+      const contract = await factory.deploy({ gasLimit })
+      await contract.waitForDeployment()
+
+      const balance = BigInt("1000000000000000000")
+      const zeroAllowance = BigInt(0)
+      const amount = BigInt("100000000000000000")
+
+      try {
+        const tx = await contract.transferWithAllowanceTest(
+          balance,
+          BigInt(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: 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
+        }
+      }
+    })
+  })
+})
+

package/test/utils/mpc/MinMax128.test.ts

@@ -0,0 +1,44 @@
+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[],
+  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 params = [
+  BigInt("1000000000000000000"),
+  BigInt("500000000000000000")
+]
+const [a, b] = params
+
+describe("MinMax 128-bit", function () {
+  buildTest("MinMax128TestsContract", "minTest", "getMinResult", params, a < b ? a : b)
+  buildTest("MinMax128TestsContract", "maxTest", "getMaxResult", params, a > b ? a : b)
+})
+

package/test/utils/mpc/MinMax256.test.ts

@@ -0,0 +1,44 @@
+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[],
+  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 params = [
+  BigInt("1000000000000000000"),  // 1e18
+  BigInt("500000000000000000")    // 0.5e18
+]
+const [a, b] = params
+
+describe("MinMax 256-bit", function () {
+  buildTest("MinMax256TestsContract", "minTest", "getMinResult", params, a < b ? a : b)
+  buildTest("MinMax256TestsContract", "maxTest", "getMaxResult", params, a > b ? a : b)
+})
+