@coti-io/coti-contracts 1.0.9 → 1.2.0

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

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract CheckedArithmetic128WithOverflowBitTestsContract {
+    uint128 addResult;
+    uint128 subResult;
+    uint128 mulResult;
+    bool overflowBit;
+
+    function getAddResult() public view returns (uint128) {
+        return addResult;
+    }
+
+    function getSubResult() public view returns (uint128) {
+        return subResult;
+    }
+
+    function getMulResult() public view returns (uint128) {
+        return mulResult;
+    }
+
+    function getOverflowBit() public view returns (bool) {
+        return overflowBit;
+    }
+
+    function checkedAddWithOverflowBitTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        (gtBool overflow, gtUint128 gtResult) = MpcCore.checkedAddWithOverflowBit(a128, b128);
+        uint128 result = uint128(MpcCore.decrypt(gtResult));
+        overflowBit = MpcCore.decrypt(overflow);
+        addResult = result;
+        
+        return result;
+    }
+
+    function checkedSubWithOverflowBitTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        (gtBool overflow, gtUint128 gtResult) = MpcCore.checkedSubWithOverflowBit(a128, b128);
+        uint128 result = uint128(MpcCore.decrypt(gtResult));
+        overflowBit = MpcCore.decrypt(overflow);
+        subResult = result;
+        
+        return result;
+    }
+
+    function checkedMulWithOverflowBitTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        (gtBool overflow, gtUint128 gtResult) = MpcCore.checkedMulWithOverflowBit(a128, b128);
+        uint128 result = uint128(MpcCore.decrypt(gtResult));
+        overflowBit = MpcCore.decrypt(overflow);
+        mulResult = result;
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract CheckedArithmetic256WithOverflowBitTestsContract {
+    uint256 addResult;
+    uint256 subResult;
+    uint256 mulResult;
+    bool overflowBit;
+
+    function getAddResult() public view returns (uint256) {
+        return addResult;
+    }
+
+    function getSubResult() public view returns (uint256) {
+        return subResult;
+    }
+
+    function getMulResult() public view returns (uint256) {
+        return mulResult;
+    }
+
+    function getOverflowBit() public view returns (bool) {
+        return overflowBit;
+    }
+
+    function checkedAddWithOverflowBitTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        (gtBool overflow, gtUint256 gtResult) = MpcCore.checkedAddWithOverflowBit(a256, b256);
+        uint256 result = MpcCore.decrypt(gtResult);
+        overflowBit = MpcCore.decrypt(overflow);
+        addResult = result;
+        
+        return result;
+    }
+
+    function checkedSubWithOverflowBitTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        (gtBool overflow, gtUint256 gtResult) = MpcCore.checkedSubWithOverflowBit(a256, b256);
+        uint256 result = MpcCore.decrypt(gtResult);
+        overflowBit = MpcCore.decrypt(overflow);
+        subResult = result;
+        
+        return result;
+    }
+
+    function checkedMulWithOverflowBitTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        (gtBool overflow, gtUint256 gtResult) = MpcCore.checkedMulWithOverflowBit(a256, b256);
+        uint256 result = MpcCore.decrypt(gtResult);
+        overflowBit = MpcCore.decrypt(overflow);
+        mulResult = result;
+        
+        return result;
+    }
+}
+

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()) }
+        }
+    }
+}
+