@coti-io/coti-contracts 1.0.9 → 1.2.0

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

@@ -0,0 +1,267 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/**
+ * @title MpcOperations128TestContract
+ * @dev Contract to test uint128 MPC operations with offBoardToUser functionality
+ * This allows users to decrypt the results of operations performed on encrypted uint128 values
+ */
+contract MpcOperations128TestContract {
+    
+    // Events for tracking operations
+    event OperationPerformed(string operation, address indexed user);
+    event ValueOffBoarded128(address indexed user, ctUint128 result);
+    
+    /**
+     * @dev Add two encrypted 128-bit values and return result encrypted for user
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function add128(itUint128 memory a, itUint128 memory b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.add(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("add128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Subtract two encrypted 128-bit values and return result encrypted for user
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)  
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function sub128(itUint128 calldata a, itUint128 calldata b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.sub(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("sub128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Multiply two encrypted 128-bit values and return result encrypted for user
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function mul128(itUint128 calldata a, itUint128 calldata b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.mul(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("mul128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Divide two encrypted 128-bit values and return result encrypted for user
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function div128(itUint128 calldata a, itUint128 calldata b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.div(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("div128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Get remainder of division and return result encrypted for user
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function rem128(itUint128 calldata a, itUint128 calldata b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.rem(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("rem128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Perform AND operation on two encrypted 128-bit values
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function and128(itUint128 calldata a, itUint128 calldata b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.and(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("and128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Perform OR operation on two encrypted 128-bit values
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function or128(itUint128 calldata a, itUint128 calldata b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.or(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("or128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Perform XOR operation on two encrypted 128-bit values
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function xor128(itUint128 calldata a, itUint128 calldata b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.xor(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("xor128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Shift left operation on encrypted 128-bit value
+     * @param a Encrypted value to shift (itUint128)
+     * @param bits Number of bits to shift (plain, must be uint8)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function shl128(itUint128 calldata a, uint8 bits, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        
+        gtUint128 result = MpcCore.shl(gtA, bits);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("shl128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Shift right operation on encrypted 128-bit value
+     * @param a Encrypted value to shift (itUint128)
+     * @param bits Number of bits to shift (plain, must be uint8)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function shr128(itUint128 calldata a, uint8 bits, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        
+        gtUint128 result = MpcCore.shr(gtA, bits);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("shr128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Get minimum of two encrypted values
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function min128(itUint128 calldata a, itUint128 calldata b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.min(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("min128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+    
+    /**
+     * @dev Get maximum of two encrypted values
+     * @param a First encrypted value (itUint128)
+     * @param b Second encrypted value (itUint128)
+     * @param user Address to encrypt result for
+     * @return Result encrypted for the user (ctUint128)
+     */
+    function max128(itUint128 calldata a, itUint128 calldata b, address user) public returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.max(gtA, gtB);
+        
+        ctUint128 ctResult = MpcCore.offBoardToUser(result, user);
+        
+        emit OperationPerformed("max128", user);
+        emit ValueOffBoarded128(user, ctResult);
+        
+        return ctResult;
+    }
+}
+

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;
+    }
+}
+