@coti-io/coti-contracts 1.0.8 → 1.1.0

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

@@ -0,0 +1,260 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Arithmetic128BitTestsContract {
+
+    bool[] public overflows;
+    bool[] public overflowsLHS;
+    bool[] public overflowsRHS;
+    uint128[] public numbers;
+    uint128[] public numbersLHS;
+    uint128[] public numbersRHS;
+
+    function addTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            numbers[i] = MpcCore.decrypt(MpcCore.add(gtA, gtB));
+
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.add(a[i], gtB)));
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.add(gtA, b[i])));
+        }
+    }
+
+    function checkedAddTest(uint128 a, uint128 b) public {
+        _resetNumbers(1);
+
+        gtUint128 memory gtA = MpcCore.setPublic128(a);
+        gtUint128 memory gtB = MpcCore.setPublic128(b);
+
+        numbers[0] = MpcCore.decrypt(MpcCore.checkedAdd(gtA, gtB));
+
+        assert(numbers[0] == MpcCore.decrypt(MpcCore.checkedAdd(a, gtB)));
+        assert(numbers[0] == MpcCore.decrypt(MpcCore.checkedAdd(gtA, b)));
+    }
+
+    function checkedAddWithOverflowBitTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetOverflows(a.length);
+        _resetOverflowsLHS(a.length);
+        _resetOverflowsRHS(a.length);
+        _resetNumbers(a.length);
+        _resetNumbersLHS(a.length);
+        _resetNumbersRHS(a.length);
+
+        gtBool bit;
+        gtBool bitLHS;
+        gtBool bitRHS;
+        gtUint128 memory result;
+        gtUint128 memory resultLHS;
+        gtUint128 memory resultRHS;
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            (bit, result) = MpcCore.checkedAddWithOverflowBit(gtA, gtB);
+            (bitLHS, resultLHS) = MpcCore.checkedAddWithOverflowBit(a[i], gtB);
+            (bitRHS, resultRHS) = MpcCore.checkedAddWithOverflowBit(gtA, b[i]);
+
+            overflows[i] = MpcCore.decrypt(bit);
+            overflowsLHS[i] = MpcCore.decrypt(bitLHS);
+            overflowsRHS[i] = MpcCore.decrypt(bitRHS);
+            numbers[i] = MpcCore.decrypt(result);
+            numbersLHS[i] = MpcCore.decrypt(resultLHS);
+            numbersRHS[i] = MpcCore.decrypt(resultRHS);
+        }
+    }
+
+    function subTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            numbers[i] = MpcCore.decrypt(MpcCore.sub(gtA, gtB));
+
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.sub(a[i], gtB)));
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.sub(gtA, b[i])));
+        }
+    }
+
+    function checkedSubTest(uint128 a, uint128 b) public {
+        _resetNumbers(1);
+
+        gtUint128 memory gtA = MpcCore.setPublic128(a);
+        gtUint128 memory gtB = MpcCore.setPublic128(b);
+
+        numbers[0] = MpcCore.decrypt(MpcCore.checkedSub(gtA, gtB));
+
+        assert(numbers[0] == MpcCore.decrypt(MpcCore.checkedSub(a, gtB)));
+        assert(numbers[0] == MpcCore.decrypt(MpcCore.checkedSub(gtA, b)));
+    }
+
+    function checkedSubWithOverflowBitTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetOverflows(a.length);
+        _resetOverflowsLHS(a.length);
+        _resetOverflowsRHS(a.length);
+        _resetNumbers(a.length);
+        _resetNumbersLHS(a.length);
+        _resetNumbersRHS(a.length);
+
+        gtBool bit;
+        gtBool bitLHS;
+        gtBool bitRHS;
+        gtUint128 memory result;
+        gtUint128 memory resultLHS;
+        gtUint128 memory resultRHS;
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            (bit, result) = MpcCore.checkedSubWithOverflowBit(gtA, gtB);
+            (bitLHS, resultLHS) = MpcCore.checkedSubWithOverflowBit(a[i], gtB);
+            (bitRHS, resultRHS) = MpcCore.checkedSubWithOverflowBit(gtA, b[i]);
+
+            overflows[i] = MpcCore.decrypt(bit);
+            overflowsLHS[i] = MpcCore.decrypt(bitLHS);
+            overflowsRHS[i] = MpcCore.decrypt(bitRHS);
+            numbers[i] = MpcCore.decrypt(result);
+            numbersLHS[i] = MpcCore.decrypt(resultLHS);
+            numbersRHS[i] = MpcCore.decrypt(resultRHS);
+        }
+    }
+
+    function mulTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            numbers[i] = MpcCore.decrypt(MpcCore.mul(gtA, gtB));
+
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.mul(a[i], gtB)));
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.mul(gtA, b[i])));
+        }
+    }
+
+    function checkedMulTest(uint128 a, uint128 b) public {
+        _resetNumbers(1);
+
+        gtUint128 memory gtA = MpcCore.setPublic128(a);
+        gtUint128 memory gtB = MpcCore.setPublic128(b);
+
+        numbers[0] = MpcCore.decrypt(MpcCore.checkedMul(gtA, gtB));
+
+        assert(numbers[0] == MpcCore.decrypt(MpcCore.checkedMul(a, gtB)));
+        assert(numbers[0] == MpcCore.decrypt(MpcCore.checkedMul(gtA, b)));
+    }
+
+    function checkedMulWithOverflowBitTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetOverflows(a.length);
+        _resetOverflowsLHS(a.length);
+        _resetOverflowsRHS(a.length);
+        _resetNumbers(a.length);
+        _resetNumbersLHS(a.length);
+        _resetNumbersRHS(a.length);
+
+        gtBool bit;
+        gtBool bitLHS;
+        gtBool bitRHS;
+        gtUint128 memory result;
+        gtUint128 memory resultLHS;
+        gtUint128 memory resultRHS;
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            (bit, result) = MpcCore.checkedMulWithOverflowBit(gtA, gtB);
+            (bitLHS, resultLHS) = MpcCore.checkedMulWithOverflowBit(a[i], gtB);
+            (bitRHS, resultRHS) = MpcCore.checkedMulWithOverflowBit(gtA, b[i]);
+
+            overflows[i] = MpcCore.decrypt(bit);
+            overflowsLHS[i] = MpcCore.decrypt(bitLHS);
+            overflowsRHS[i] = MpcCore.decrypt(bitRHS);
+            numbers[i] = MpcCore.decrypt(result);
+            numbersLHS[i] = MpcCore.decrypt(resultLHS);
+            numbersRHS[i] = MpcCore.decrypt(resultRHS);
+        }
+    }
+
+    function _resetOverflows(uint256 length) internal {
+        // Reset the overflows array
+        delete overflows;
+        
+        // Resize the overflows array to match input length
+        for(uint i = 0; i < length; i++) {
+            overflows.push(false);
+        }
+    }
+
+    function _resetOverflowsLHS(uint256 length) internal {
+        // Reset the overflows array
+        delete overflowsLHS;
+        
+        // Resize the overflows array to match input length
+        for(uint i = 0; i < length; i++) {
+            overflowsLHS.push(false);
+        }
+    }
+
+    function _resetOverflowsRHS(uint256 length) internal {
+        // Reset the overflows array
+        delete overflowsRHS;
+        
+        // Resize the overflows array to match input length
+        for(uint i = 0; i < length; i++) {
+            overflowsRHS.push(false);
+        }
+    }
+
+    function _resetNumbers(uint256 length) internal {
+        // Reset the numbers array
+        delete numbers;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbers.push(0);
+        }
+    }
+
+    function _resetNumbersLHS(uint256 length) internal {
+        // Reset the numbers array
+        delete numbersLHS;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbersLHS.push(0);
+        }
+    }
+
+    function _resetNumbersRHS(uint256 length) internal {
+        // Reset the numbers array
+        delete numbersRHS;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbersRHS.push(0);
+        }
+    }
+}

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

@@ -0,0 +1,264 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Arithmetic256BitTestsContract {
+
+    enum PrivateInput {
+        BOTH,
+        LHS,
+        RHS
+    }
+
+    bool[] public overflows;
+    bool[] public overflowsLHS;
+    bool[] public overflowsRHS;
+    uint256[] public numbers2;
+    uint256[] public numbersLHS2;
+    uint256[] public numbersRHS2;
+
+    function addTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            numbers2[i] = MpcCore.decrypt(MpcCore.add(gtA, gtB));
+
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.add(a[i], gtB)));
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.add(gtA, b[i])));
+        }
+    }
+
+    function checkedAddTest(uint256 a, uint256 b) public {
+        _resetNumbers2(1);
+
+        gtUint256 memory gtA = MpcCore.setPublic256(a);
+        gtUint256 memory gtB = MpcCore.setPublic256(b);
+
+        numbers2[0] = MpcCore.decrypt(MpcCore.checkedAdd(gtA, gtB));
+
+        assert(numbers2[0] == MpcCore.decrypt(MpcCore.checkedAdd(a, gtB)));
+        assert(numbers2[0] == MpcCore.decrypt(MpcCore.checkedAdd(gtA, b)));
+    }
+
+    function checkedAddWithOverflowBitTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetOverflows(a.length);
+        _resetOverflowsLHS(a.length);
+        _resetOverflowsRHS(a.length);
+        _resetNumbers2(a.length);
+        _resetNumbersLHS2(a.length);
+        _resetNumbersRHS2(a.length);
+
+        gtBool bit;
+        gtBool bitLHS;
+        gtBool bitRHS;
+        gtUint256 memory result;
+        gtUint256 memory resultLHS;
+        gtUint256 memory resultRHS;
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            (bit, result) = MpcCore.checkedAddWithOverflowBit(gtA, gtB);
+            (bitLHS, resultLHS) = MpcCore.checkedAddWithOverflowBit(a[i], gtB);
+            (bitRHS, resultRHS) = MpcCore.checkedAddWithOverflowBit(gtA, b[i]);
+
+            overflows[i] = MpcCore.decrypt(bit);
+            overflowsLHS[i] = MpcCore.decrypt(bitLHS);
+            overflowsRHS[i] = MpcCore.decrypt(bitRHS);
+            numbers2[i] = MpcCore.decrypt(result);
+            numbersLHS2[i] = MpcCore.decrypt(resultLHS);
+            numbersRHS2[i] = MpcCore.decrypt(resultRHS);
+        }
+    }
+
+    function subTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            numbers2[i] = MpcCore.decrypt(MpcCore.sub(gtA, gtB));
+
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.sub(a[i], gtB)));
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.sub(gtA, b[i])));
+        }
+    }
+
+    function checkedSubTest(uint256 a, uint256 b) public {
+        _resetNumbers2(1);
+
+        gtUint256 memory gtA = MpcCore.setPublic256(a);
+        gtUint256 memory gtB = MpcCore.setPublic256(b);
+
+        numbers2[0] = MpcCore.decrypt(MpcCore.checkedSub(gtA, gtB));
+
+        assert(numbers2[0] == MpcCore.decrypt(MpcCore.checkedSub(a, gtB)));
+        assert(numbers2[0] == MpcCore.decrypt(MpcCore.checkedSub(gtA, b)));
+    }
+
+    function checkedSubWithOverflowBitTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetOverflows(a.length);
+        _resetOverflowsLHS(a.length);
+        _resetOverflowsRHS(a.length);
+        _resetNumbers2(a.length);
+        _resetNumbersLHS2(a.length);
+        _resetNumbersRHS2(a.length);
+
+        gtBool bit;
+        gtBool bitLHS;
+        gtBool bitRHS;
+        gtUint256 memory result;
+        gtUint256 memory resultLHS;
+        gtUint256 memory resultRHS;
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            (bit, result) = MpcCore.checkedSubWithOverflowBit(gtA, gtB);
+            (bitLHS, resultLHS) = MpcCore.checkedSubWithOverflowBit(a[i], gtB);
+            (bitRHS, resultRHS) = MpcCore.checkedSubWithOverflowBit(gtA, b[i]);
+
+            overflows[i] = MpcCore.decrypt(bit);
+            overflowsLHS[i] = MpcCore.decrypt(bitLHS);
+            overflowsRHS[i] = MpcCore.decrypt(bitRHS);
+            numbers2[i] = MpcCore.decrypt(result);
+            numbersLHS2[i] = MpcCore.decrypt(resultLHS);
+            numbersRHS2[i] = MpcCore.decrypt(resultRHS);
+        }
+    }
+
+    function mulTest(uint256[] calldata a, uint256[] calldata b, PrivateInput privateInput) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            if (privateInput == PrivateInput.BOTH) {
+                numbers2[i] = MpcCore.decrypt(MpcCore.mul(gtA, gtB));
+            } else if (privateInput == PrivateInput.LHS) {
+                numbers2[i] = MpcCore.decrypt(MpcCore.mul(gtA, b[i]));
+            } else if (privateInput == PrivateInput.RHS) {
+                numbers2[i] = MpcCore.decrypt(MpcCore.mul(a[i], gtB));
+            }
+        }
+    }
+
+    function checkedMulTest(uint256 a, uint256 b, PrivateInput privateInput) public {
+        _resetNumbers2(1);
+
+        gtUint256 memory gtA = MpcCore.setPublic256(a);
+        gtUint256 memory gtB = MpcCore.setPublic256(b);
+
+        if (privateInput == PrivateInput.BOTH) {
+            numbers2[0] = MpcCore.decrypt(MpcCore.checkedMul(gtA, gtB));
+        } else if (privateInput == PrivateInput.LHS) {
+            numbers2[0] = MpcCore.decrypt(MpcCore.checkedMul(gtA, b));
+        } else if (privateInput == PrivateInput.RHS) {
+            numbers2[0] = MpcCore.decrypt(MpcCore.checkedMul(a, gtB));
+        }
+    }
+
+    function checkedMulWithOverflowBitTest(uint256[] calldata a, uint256[] calldata b, PrivateInput privateInput) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetOverflows(a.length);
+        _resetNumbers2(a.length);
+
+        gtBool bit;
+        gtUint256 memory result;
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            if (privateInput == PrivateInput.BOTH) {
+                (bit, result) = MpcCore.checkedMulWithOverflowBit(gtA, gtB);
+            } else if (privateInput == PrivateInput.LHS) {
+                (bit, result) = MpcCore.checkedMulWithOverflowBit(a[i], gtB);
+            } else if (privateInput == PrivateInput.RHS) {
+                (bit, result) = MpcCore.checkedMulWithOverflowBit(gtA, b[i]);
+            }
+
+            overflows[i] = MpcCore.decrypt(bit);
+            numbers2[i] = MpcCore.decrypt(result);
+        }
+    }
+
+    function _resetOverflows(uint256 length) internal {
+        // Reset the overflows array
+        delete overflows;
+        
+        // Resize the overflows array to match input length
+        for(uint i = 0; i < length; i++) {
+            overflows.push(false);
+        }
+    }
+
+    function _resetOverflowsLHS(uint256 length) internal {
+        // Reset the overflows array
+        delete overflowsLHS;
+        
+        // Resize the overflows array to match input length
+        for(uint i = 0; i < length; i++) {
+            overflowsLHS.push(false);
+        }
+    }
+
+    function _resetOverflowsRHS(uint256 length) internal {
+        // Reset the overflows array
+        delete overflowsRHS;
+        
+        // Resize the overflows array to match input length
+        for(uint i = 0; i < length; i++) {
+            overflowsRHS.push(false);
+        }
+    }
+
+    function _resetNumbers2(uint256 length) internal {
+        // Reset the numbers array
+        delete numbers2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbers2.push(0);
+        }
+    }
+
+    function _resetNumbersLHS2(uint256 length) internal {
+        // Reset the numbers array
+        delete numbersLHS2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbersLHS2.push(0);
+        }
+    }
+
+    function _resetNumbersRHS2(uint256 length) internal {
+        // Reset the numbers array
+        delete numbersRHS2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbersRHS2.push(0);
+        }
+    }
+}

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

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Bitwise128BitTestsContract {
+
+    uint128[] public numbers;
+
+    function andTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            numbers[i] = MpcCore.decrypt(MpcCore.and(gtA, gtB));
+
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.and(a[i], gtB)));
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.and(gtA, b[i])));
+        }
+    }
+
+    function orTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            numbers[i] = MpcCore.decrypt(MpcCore.or(gtA, gtB));
+
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.or(a[i], gtB)));
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.or(gtA, b[i])));
+        }
+    }
+
+    function xorTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            numbers[i] = MpcCore.decrypt(MpcCore.xor(gtA, gtB));
+
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.xor(a[i], gtB)));
+            assert(numbers[i] == MpcCore.decrypt(MpcCore.xor(gtA, b[i])));
+        }
+    }
+
+    function shlTest(uint128[] calldata a, uint8[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            
+            numbers[i] = MpcCore.decrypt(MpcCore.shl(gtA, b[i]));
+        }
+    }
+
+    function shrTest(uint128[] calldata a, uint8[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            
+            numbers[i] = MpcCore.decrypt(MpcCore.shr(gtA, b[i]));
+        }
+    }
+
+    function _resetNumbers(uint256 length) internal {
+        // Reset the numbers array
+        delete numbers;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbers.push(0);
+        }
+    }
+}

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

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Bitwise256BitTestsContract {
+
+    uint256[] public numbers2;
+
+    function andTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            numbers2[i] = MpcCore.decrypt(MpcCore.and(gtA, gtB));
+
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.and(a[i], gtB)));
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.and(gtA, b[i])));
+        }
+    }
+
+    function orTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            numbers2[i] = MpcCore.decrypt(MpcCore.or(gtA, gtB));
+
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.or(a[i], gtB)));
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.or(gtA, b[i])));
+        }
+    }
+
+    function xorTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            numbers2[i] = MpcCore.decrypt(MpcCore.xor(gtA, gtB));
+
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.xor(a[i], gtB)));
+            assert(numbers2[i] == MpcCore.decrypt(MpcCore.xor(gtA, b[i])));
+        }
+    }
+
+    function shlTest(uint256[] calldata a, uint8[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            
+            numbers2[i] = MpcCore.decrypt(MpcCore.shl(gtA, b[i]));
+        }
+    }
+
+    function shrTest(uint256[] calldata a, uint8[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            
+            numbers2[i] = MpcCore.decrypt(MpcCore.shr(gtA, b[i]));
+        }
+    }
+
+    function _resetNumbers2(uint256 length) internal {
+        // Reset the numbers array
+        delete numbers2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbers2.push(0);
+        }
+    }
+}