@coti-io/coti-contracts 1.1.0 → 1.3.0

package/contracts/mocks/utils/mpc/MpcOperationsTestContract.sol

@@ -0,0 +1,334 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/**
+ * @title MpcOperationsTestContract
+ * @dev Contract to test various MPC operations with offBoardToUser functionality
+ * This allows users to decrypt the results of operations performed on encrypted values
+ */
+contract MpcOperationsTestContract {
+    
+    // Events for tracking operations
+    event OperationPerformed(string operation, address indexed user);
+    event ValueOffBoarded(address indexed user, ctUint256 result);
+    
+    /**
+     * @dev Add two encrypted 256-bit values and return result encrypted for user
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function add256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.add(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("add256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Subtract two encrypted 256-bit values and return result encrypted for user
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)  
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function sub256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.sub(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("sub256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Multiply two encrypted 256-bit values and return result encrypted for user
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function mul256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.mul(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("mul256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Divide two encrypted 256-bit values and return result encrypted for user
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function div256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.div(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("div256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Get remainder of division and return result encrypted for user
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function rem256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.rem(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("rem256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Perform AND operation on two encrypted 256-bit values
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function and256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.and(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("and256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Perform OR operation on two encrypted 256-bit values
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function or256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.or(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("or256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Perform XOR operation on two encrypted 256-bit values
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function xor256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.xor(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("xor256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Shift left operation on encrypted 256-bit value
+     * @param a Encrypted value to shift (itUint256)
+     * @param bits Number of bits to shift (plain, must be uint8)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function shl256(itUint256 memory a, uint8 bits, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        
+        gtUint256 result = MpcCore.shl(gtA, bits);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("shl256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Shift right operation on encrypted 256-bit value
+     * @param a Encrypted value to shift (itUint256)
+     * @param bits Number of bits to shift (plain, must be uint8)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function shr256(itUint256 memory a, uint8 bits, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        
+        gtUint256 result = MpcCore.shr(gtA, bits);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("shr256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Check if two encrypted values are equal
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256) - 1 if equal, 0 otherwise
+     */
+    function eq256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtBool result = MpcCore.eq(gtA, gtB);
+        gtUint256 resultAsUint = MpcCore.mux(result, MpcCore.setPublic256(1), MpcCore.setPublic256(0));
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(resultAsUint, user);
+        
+        emit OperationPerformed("eq256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Check if first value is greater than second
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256) - 1 if a > b, 0 otherwise
+     */
+    function gt256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtBool result = MpcCore.gt(gtA, gtB);
+        gtUint256 resultAsUint = MpcCore.mux(result, MpcCore.setPublic256(1), MpcCore.setPublic256(0));
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(resultAsUint, user);
+        
+        emit OperationPerformed("gt256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Check if first value is less than second
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256) - 1 if a < b, 0 otherwise
+     */
+    function lt256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtBool result = MpcCore.lt(gtA, gtB);
+        gtUint256 resultAsUint = MpcCore.mux(result, MpcCore.setPublic256(1), MpcCore.setPublic256(0));
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(resultAsUint, user);
+        
+        emit OperationPerformed("lt256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Get minimum of two encrypted values
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function min256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.min(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("min256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Get maximum of two encrypted values
+     * @param a First encrypted value (itUint256)
+     * @param b Second encrypted value (itUint256)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint256)
+     */
+    function max256(itUint256 memory a, itUint256 memory b, address user) public returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.max(gtA, gtB);
+        
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("max256", user);
+        emit ValueOffBoarded(user, ctResult);
+        
+        return ctResult;
+    }
+    
+}
+

package/contracts/mocks/utils/mpc/Mux128TestsContract.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Mux128TestsContract {
+    uint128 muxResult;
+
+    function getMuxResult() public view returns (uint128) {
+        return muxResult;
+    }
+
+    function muxTest(bool bit, uint128 a, uint128 b) public returns (uint128) {
+        gtBool bitBool = MpcCore.setPublic(bit);
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.mux(bitBool, a128, b128)));
+        muxResult = result;
+        
+        return result;
+    }
+}
+

package/contracts/mocks/utils/mpc/Mux256TestsContract.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Mux256TestsContract {
+    uint256 muxResult;
+
+    function getMuxResult() public view returns (uint256) {
+        return muxResult;
+    }
+
+    function muxTest(bool bit, uint256 a, uint256 b) public returns (uint256) {
+        gtBool bitBool = MpcCore.setPublic(bit);
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.mux(bitBool, a256, b256));
+        muxResult = result;
+        
+        return result;
+    }
+}
+

package/contracts/mocks/utils/mpc/OnBoard128TestsContract.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract OnBoard128TestsContract {
+    uint128 onboardOffboardResult;
+    ctUint128 storedCiphertext;
+
+    function getOnboardOffboardResult() public view returns (uint128) {
+        return onboardOffboardResult;
+    }
+
+    function getStoredCiphertext() public view returns (ctUint128) {
+        return storedCiphertext;
+    }
+
+    /**
+     * @dev Test the round-trip: setPublic -> offBoard -> onBoard -> decrypt
+     * @param value The value to test
+     */
+    function testOnBoardOffBoardRoundTrip(uint128 value) public returns (uint128) {
+        // Step 1: Create garbled text from public value
+        gtUint128 gtValue = MpcCore.setPublic128(value);
+        
+        // Step 2: Convert garbled text to ciphertext (offBoard)
+        ctUint128 ciphertext = MpcCore.offBoard(gtValue);
+        storedCiphertext = ciphertext;
+        
+        // Step 3: Convert ciphertext back to garbled text (onBoard)
+        gtUint128 gtValue2 = MpcCore.onBoard(ciphertext);
+        
+        // Step 4: Decrypt to verify the value
+        uint128 result = MpcCore.decrypt(gtValue2);
+        onboardOffboardResult = result;
+        
+        require(result == value, "OnBoard/OffBoard round-trip failed");
+        
+        return result;
+    }
+
+    /**
+     * @dev Test onBoard with multiple values
+     */
+    function testOnBoardMultipleValues(uint128 a, uint128 b, uint128 c) public returns (uint128, uint128, uint128) {
+        // Test value A
+        gtUint128 gtA = MpcCore.setPublic128(a);
+        ctUint128 ctA = MpcCore.offBoard(gtA);
+        gtUint128 gtA2 = MpcCore.onBoard(ctA);
+        uint128 resultA = MpcCore.decrypt(gtA2);
+        require(resultA == a, "Value A test failed");
+        
+        // Test value B
+        gtUint128 gtB = MpcCore.setPublic128(b);
+        ctUint128 ctB = MpcCore.offBoard(gtB);
+        gtUint128 gtB2 = MpcCore.onBoard(ctB);
+        uint128 resultB = MpcCore.decrypt(gtB2);
+        require(resultB == b, "Value B test failed");
+        
+        // Test value C
+        gtUint128 gtC = MpcCore.setPublic128(c);
+        ctUint128 ctC = MpcCore.offBoard(gtC);
+        gtUint128 gtC2 = MpcCore.onBoard(ctC);
+        uint128 resultC = MpcCore.decrypt(gtC2);
+        require(resultC == c, "Value C test failed");
+        
+        return (resultA, resultB, resultC);
+    }
+
+    /**
+     * @dev Test onBoard with edge cases (0 and max)
+     */
+    function testOnBoardEdgeCases() public returns (uint128, uint128) {
+        // Test zero
+        uint128 zero = 0;
+        gtUint128 gtZero = MpcCore.setPublic128(zero);
+        ctUint128 ctZero = MpcCore.offBoard(gtZero);
+        gtUint128 gtZero2 = MpcCore.onBoard(ctZero);
+        uint128 resultZero = MpcCore.decrypt(gtZero2);
+        require(resultZero == zero, "Zero test failed");
+        
+        // Test max
+        uint128 max = type(uint128).max;
+        gtUint128 gtMax = MpcCore.setPublic128(max);
+        ctUint128 ctMax = MpcCore.offBoard(gtMax);
+        gtUint128 gtMax2 = MpcCore.onBoard(ctMax);
+        uint128 resultMax = MpcCore.decrypt(gtMax2);
+        require(resultMax == max, "Max test failed");
+        
+        return (resultZero, resultMax);
+    }
+}
+

package/contracts/mocks/utils/mpc/OnBoard256TestsContract.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract OnBoard256TestsContract {
+    uint256 onboardOffboardResult;
+    ctUint256 storedCiphertext;
+
+    function getOnboardOffboardResult() public view returns (uint256) {
+        return onboardOffboardResult;
+    }
+
+    function getStoredCiphertext() public view returns (ctUint256 memory) {
+        return storedCiphertext;
+    }
+
+    /**
+     * @dev Test the round-trip: setPublic -> offBoard -> onBoard -> decrypt
+     * @param value The value to test
+     */
+    function testOnBoardOffBoardRoundTrip(uint256 value) public returns (uint256) {
+        // Step 1: Create garbled text from public value
+        gtUint256 gtValue = MpcCore.setPublic256(value);
+        
+        // Step 2: Convert garbled text to ciphertext (offBoard)
+        ctUint256 memory ciphertext = MpcCore.offBoard(gtValue);
+        storedCiphertext = ciphertext;
+        
+        // Step 3: Convert ciphertext back to garbled text (onBoard)
+        gtUint256 gtValue2 = MpcCore.onBoard(ciphertext);
+        
+        // Step 4: Decrypt to verify the value
+        uint256 result = MpcCore.decrypt(gtValue2);
+        onboardOffboardResult = result;
+        
+        require(result == value, "OnBoard/OffBoard round-trip failed");
+        
+        return result;
+    }
+
+    /**
+     * @dev Test onBoard with multiple values
+     */
+    function testOnBoardMultipleValues(uint256 a, uint256 b, uint256 c) public returns (uint256, uint256, uint256) {
+        // Test value A
+        gtUint256 gtA = MpcCore.setPublic256(a);
+        ctUint256 memory ctA = MpcCore.offBoard(gtA);
+        gtUint256 gtA2 = MpcCore.onBoard(ctA);
+        uint256 resultA = MpcCore.decrypt(gtA2);
+        require(resultA == a, "Value A test failed");
+        
+        // Test value B
+        gtUint256 gtB = MpcCore.setPublic256(b);
+        ctUint256 memory ctB = MpcCore.offBoard(gtB);
+        gtUint256 gtB2 = MpcCore.onBoard(ctB);
+        uint256 resultB = MpcCore.decrypt(gtB2);
+        require(resultB == b, "Value B test failed");
+        
+        // Test value C
+        gtUint256 gtC = MpcCore.setPublic256(c);
+        ctUint256 memory ctC = MpcCore.offBoard(gtC);
+        gtUint256 gtC2 = MpcCore.onBoard(ctC);
+        uint256 resultC = MpcCore.decrypt(gtC2);
+        require(resultC == c, "Value C test failed");
+        
+        return (resultA, resultB, resultC);
+    }
+
+    /**
+     * @dev Test onBoard with edge cases (0 and max)
+     */
+    function testOnBoardEdgeCases() public returns (uint256, uint256) {
+        // Test zero
+        uint256 zero = 0;
+        gtUint256 gtZero = MpcCore.setPublic256(zero);
+        ctUint256 memory ctZero = MpcCore.offBoard(gtZero);
+        gtUint256 gtZero2 = MpcCore.onBoard(ctZero);
+        uint256 resultZero = MpcCore.decrypt(gtZero2);
+        require(resultZero == zero, "Zero test failed");
+        
+        // Test max
+        uint256 max = type(uint256).max;
+        gtUint256 gtMax = MpcCore.setPublic256(max);
+        ctUint256 memory ctMax = MpcCore.offBoard(gtMax);
+        gtUint256 gtMax2 = MpcCore.onBoard(ctMax);
+        uint256 resultMax = MpcCore.decrypt(gtMax2);
+        require(resultMax == max, "Max test failed");
+        
+        return (resultZero, resultMax);
+    }
+
+    /**
+     * @dev Test onBoard with values that cross 128-bit boundary
+     */
+    function testOnBoard128BitBoundary() public returns (uint256, uint256) {
+        // Test value below 128-bit boundary (2^127 - 1)
+        uint256 below128 = (uint256(1) << 127) - 1;
+        gtUint256 gtBelow = MpcCore.setPublic256(below128);
+        ctUint256 memory ctBelow = MpcCore.offBoard(gtBelow);
+        gtUint256 gtBelow2 = MpcCore.onBoard(ctBelow);
+        uint256 resultBelow = MpcCore.decrypt(gtBelow2);
+        require(resultBelow == below128, "Below 128-bit test failed");
+        
+        // Test value above 128-bit boundary (2^128)
+        uint256 above128 = uint256(1) << 128;
+        gtUint256 gtAbove = MpcCore.setPublic256(above128);
+        ctUint256 memory ctAbove = MpcCore.offBoard(gtAbove);
+        gtUint256 gtAbove2 = MpcCore.onBoard(ctAbove);
+        uint256 resultAbove = MpcCore.decrypt(gtAbove2);
+        require(resultAbove == above128, "Above 128-bit test failed");
+        
+        return (resultBelow, resultAbove);
+    }
+}
+