@coti-io/coti-contracts 1.1.0 → 1.3.0

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

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Comparison128TestsContract {
+    bool eqResult;
+    bool neResult;
+    bool geResult;
+    bool gtResult;
+    bool leResult;
+    bool ltResult;
+
+    function getEqResult() public view returns (bool) {
+        return eqResult;
+    }
+
+    function getNeResult() public view returns (bool) {
+        return neResult;
+    }
+
+    function getGeResult() public view returns (bool) {
+        return geResult;
+    }
+
+    function getGtResult() public view returns (bool) {
+        return gtResult;
+    }
+
+    function getLeResult() public view returns (bool) {
+        return leResult;
+    }
+
+    function getLtResult() public view returns (bool) {
+        return ltResult;
+    }
+
+    function eqTest(uint128 a, uint128 b) public returns (bool) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.eq(a128, b128));
+        eqResult = result;
+        
+        return result;
+    }
+
+    function neTest(uint128 a, uint128 b) public returns (bool) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.ne(a128, b128));
+        neResult = result;
+        
+        return result;
+    }
+
+    function geTest(uint128 a, uint128 b) public returns (bool) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.ge(a128, b128));
+        geResult = result;
+        
+        return result;
+    }
+
+    function gtTest(uint128 a, uint128 b) public returns (bool) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.gt(a128, b128));
+        gtResult = result;
+        
+        return result;
+    }
+
+    function leTest(uint128 a, uint128 b) public returns (bool) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.le(a128, b128));
+        leResult = result;
+        
+        return result;
+    }
+
+    function ltTest(uint128 a, uint128 b) public returns (bool) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.lt(a128, b128));
+        ltResult = result;
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Comparison256TestsContract {
+    bool eqResult;
+    bool neResult;
+    bool geResult;
+    bool gtResult;
+    bool leResult;
+    bool ltResult;
+
+    function getEqResult() public view returns (bool) {
+        return eqResult;
+    }
+
+    function getNeResult() public view returns (bool) {
+        return neResult;
+    }
+
+    function getGeResult() public view returns (bool) {
+        return geResult;
+    }
+
+    function getGtResult() public view returns (bool) {
+        return gtResult;
+    }
+
+    function getLeResult() public view returns (bool) {
+        return leResult;
+    }
+
+    function getLtResult() public view returns (bool) {
+        return ltResult;
+    }
+
+    function eqTest(uint256 a, uint256 b) public returns (bool) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.eq(a256, b256));
+        eqResult = result;
+        
+        return result;
+    }
+
+    function neTest(uint256 a, uint256 b) public returns (bool) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.ne(a256, b256));
+        neResult = result;
+        
+        return result;
+    }
+
+    function geTest(uint256 a, uint256 b) public returns (bool) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.ge(a256, b256));
+        geResult = result;
+        
+        return result;
+    }
+
+    function gtTest(uint256 a, uint256 b) public returns (bool) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.gt(a256, b256));
+        gtResult = result;
+        
+        return result;
+    }
+
+    function leTest(uint256 a, uint256 b) public returns (bool) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.le(a256, b256));
+        leResult = result;
+        
+        return result;
+    }
+
+    function ltTest(uint256 a, uint256 b) public returns (bool) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        bool result = MpcCore.decrypt(MpcCore.lt(a256, b256));
+        ltResult = result;
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract MinMax128TestsContract {
+    uint128 minResult;
+    uint128 maxResult;
+
+    function getMinResult() public view returns (uint128) {
+        return minResult;
+    }
+
+    function getMaxResult() public view returns (uint128) {
+        return maxResult;
+    }
+
+    function minTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.min(a128, b128)));
+        minResult = result;
+        
+        require(result == uint128(MpcCore.decrypt(MpcCore.min(a, b128))), "minTest: scalar failed");
+        require(result == uint128(MpcCore.decrypt(MpcCore.min(a128, b))), "minTest: scalar failed");
+        
+        return result;
+    }
+
+    function maxTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.max(a128, b128)));
+        maxResult = result;
+        
+        require(result == uint128(MpcCore.decrypt(MpcCore.max(a, b128))), "maxTest: scalar failed");
+        require(result == uint128(MpcCore.decrypt(MpcCore.max(a128, b))), "maxTest: scalar failed");
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract MinMax256TestsContract {
+    uint256 minResult;
+    uint256 maxResult;
+
+    function getMinResult() public view returns (uint256) {
+        return minResult;
+    }
+
+    function getMaxResult() public view returns (uint256) {
+        return maxResult;
+    }
+
+    function minTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.min(a256, b256));
+        minResult = result;
+        
+        require(result == MpcCore.decrypt(MpcCore.min(a, b256)), "minTest: scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.min(a256, b)), "minTest: scalar failed");
+        
+        return result;
+    }
+
+    function maxTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.max(a256, b256));
+        maxResult = result;
+        
+        require(result == MpcCore.decrypt(MpcCore.max(a, b256)), "maxTest: scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.max(a256, b)), "maxTest: scalar failed");
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/**
+ * @title MinimalImplementation
+ * @notice Test IT-type validation and offBoardToUser with large numbers
+ */
+contract MinimalImplementation {
+    
+    // Storage for encrypted result (ctUint256 offBoarded to user)
+    mapping(address => ctUint256) public storedCtResult;
+    
+    event InputsReceived(address indexed user, string message);
+    event CalculationDone(address indexed user, string operation);
+    event ResultStored(address indexed user, string message);
+    
+    /**
+     * Simple addition test with offBoardToUser storage
+     * Flow: IT → validate → GT → add → GT → offBoardToUser → CT → store
+     */
+    function addAndStore(itUint256 calldata a, itUint256 calldata b) external returns (ctUint256 memory) {
+        emit InputsReceived(msg.sender, "Received encrypted inputs");
+        
+        // Step 1: Validate IT-types (offchain encrypted) → GT-types (onchain encrypted)
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        emit CalculationDone(msg.sender, "Validated ciphertexts");
+        
+        // Step 2: Add (onchain computation on encrypted values)
+        gtUint256 gtResult = MpcCore.add(gtA, gtB);
+        
+        emit CalculationDone(msg.sender, "Addition completed");
+        
+        // Step 3: OffBoard to user (GT → CT for user to decrypt)
+        ctUint256 memory ctResult = MpcCore.offBoardToUser(gtResult, msg.sender);
+        
+        // Step 4: Store the CT result
+        storedCtResult[msg.sender] = ctResult;
+        
+        emit ResultStored(msg.sender, "Result stored as ctUint256");
+        
+        return ctResult;
+    }
+    
+    /**
+     * Read stored result from storage
+     */
+    function getStoredResult() external view returns (ctUint256 memory) {
+        return storedCtResult[msg.sender];
+    }
+}
+

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

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title MinimalProxy
+ * @notice Minimal proxy to demonstrate IT-type validation issue
+ */
+contract MinimalProxy {
+    address public implementation;
+    
+    constructor(address _implementation) {
+        implementation = _implementation;
+    }
+    
+    fallback() external payable {
+        address impl = implementation;
+        assembly {
+            calldatacopy(0, 0, calldatasize())
+            let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)
+            returndatacopy(0, 0, returndatasize())
+            switch result
+            case 0 { revert(0, returndatasize()) }
+            default { return(0, returndatasize()) }
+        }
+    }
+}
+

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