@coti-io/coti-contracts 1.3.0 → 1.3.1

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

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/// @dev Signed int128 coverage — split from ArithmeticSigned256TestsContract for EIP-170.
+contract ArithmeticSigned128TestsContract {
+    function basicSigned128Test() public {
+        gtInt128 a = MpcCore.setPublic128(int128(-12));
+        gtInt128 b = MpcCore.setPublic128(int128(3));
+        gtInt128 sameA = MpcCore.setPublic128(int128(-12));
+
+        require(MpcCore.decrypt(MpcCore.add(a, b)) == -9, "int128 add");
+        require(MpcCore.decrypt(MpcCore.sub(a, b)) == -15, "int128 sub");
+        require(MpcCore.decrypt(MpcCore.mul(a, b)) == -36, "int128 mul");
+        require(MpcCore.decrypt(MpcCore.div(a, b)) == -4, "int128 div");
+        require(MpcCore.decrypt(MpcCore.checkedAdd(a, b)) == -9, "int128 checked add");
+        require(MpcCore.decrypt(MpcCore.checkedSub(a, b)) == -15, "int128 checked sub");
+        require(MpcCore.decrypt(MpcCore.checkedMul(a, b)) == -36, "int128 checked mul");
+        require(MpcCore.decrypt(MpcCore.eq(a, sameA)), "int128 eq");
+        require(MpcCore.decrypt(MpcCore.ne(a, b)), "int128 ne");
+        require(MpcCore.decrypt(MpcCore.lt(a, b)), "int128 lt");
+        require(MpcCore.decrypt(MpcCore.le(a, sameA)), "int128 le");
+        require(MpcCore.decrypt(MpcCore.gt(b, a)), "int128 gt");
+        require(MpcCore.decrypt(MpcCore.ge(sameA, a)), "int128 ge");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(true), a, b)) == 3, "int128 mux true");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(false), a, b)) == -12, "int128 mux false");
+        require(MpcCore.decrypt(MpcCore.toSigned(MpcCore.fromSigned(a))) == -12, "int128 conversion");
+        require(MpcCore.decrypt(MpcCore.negate(a)) == 12, "int128 negate");
+        require(MpcCore.decrypt(MpcCore.shl(MpcCore.setPublic128(int128(-8)), 1)) == -16, "int128 shl");
+        require(MpcCore.decrypt(MpcCore.shr(MpcCore.setPublic128(int128(-8)), 1)) == -4, "int128 shr");
+        require(MpcCore.int128ToUint128(-1) == type(uint128).max, "int128 to uint128");
+        require(MpcCore.uint128ToInt128(type(uint128).max) == -1, "uint128 to int128");
+    }
+
+    function minDivMinusOne128Test() public {
+        require(
+            MpcCore.decrypt(MpcCore.div(MpcCore.setPublic128(type(int128).min), MpcCore.setPublic128(int128(-1))))
+                == type(int128).min,
+            "int128 min div -1"
+        );
+    }
+
+    function plainMul128WrapTest() public {
+        require(
+            MpcCore.decrypt(MpcCore.mul(MpcCore.setPublic128(int128(1) << 64), MpcCore.setPublic128(int128(1) << 64)))
+                == 0,
+            "int128 mul wrap"
+        );
+    }
+
+    function checkedAdd128OverflowTest() public {
+        MpcCore.checkedAdd(MpcCore.setPublic128(type(int128).max), MpcCore.setPublic128(int128(1)));
+    }
+
+    function checkedSub128UnderflowTest() public {
+        MpcCore.checkedSub(MpcCore.setPublic128(type(int128).min), MpcCore.setPublic128(int128(1)));
+    }
+
+    function checkedMul128OverflowTest() public {
+        MpcCore.checkedMul(MpcCore.setPublic128(int128(1) << 64), MpcCore.setPublic128(int128(1) << 64));
+    }
+}

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

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/// @dev Signed int256 + checked storage helpers — narrow/128 widths live in sibling mocks (EIP-170).
+contract ArithmeticSigned256TestsContract {
+    int256 addResult;
+    int256 subResult;
+    int256 mulResult;
+
+    function getAddResult() public view returns (int256) {
+        return addResult;
+    }
+
+    function getSubResult() public view returns (int256) {
+        return subResult;
+    }
+
+    function getMulResult() public view returns (int256) {
+        return mulResult;
+    }
+
+    function checkedAddTest(int256 a, int256 b) public returns (int256) {
+        gtInt256 a256 = MpcCore.setPublic256(a);
+        gtInt256 b256 = MpcCore.setPublic256(b);
+
+        int256 result = MpcCore.decrypt(MpcCore.checkedAdd(a256, b256));
+        addResult = result;
+
+        return result;
+    }
+
+    function checkedSubTest(int256 a, int256 b) public returns (int256) {
+        gtInt256 a256 = MpcCore.setPublic256(a);
+        gtInt256 b256 = MpcCore.setPublic256(b);
+
+        int256 result = MpcCore.decrypt(MpcCore.checkedSub(a256, b256));
+        subResult = result;
+
+        return result;
+    }
+
+    function checkedMulTest(int256 a, int256 b) public returns (int256) {
+        gtInt256 a256 = MpcCore.setPublic256(a);
+        gtInt256 b256 = MpcCore.setPublic256(b);
+
+        int256 result = MpcCore.decrypt(MpcCore.checkedMul(a256, b256));
+        mulResult = result;
+
+        return result;
+    }
+
+    function basicSigned256ArithmeticTest() public {
+        gtInt256 a = MpcCore.setPublic256(int256(-12));
+        gtInt256 b = MpcCore.setPublic256(int256(3));
+
+        require(MpcCore.decrypt(MpcCore.add(a, b)) == -9, "int256 add");
+        require(MpcCore.decrypt(MpcCore.sub(a, b)) == -15, "int256 sub");
+        require(MpcCore.decrypt(MpcCore.mul(a, b)) == -36, "int256 mul");
+        require(MpcCore.decrypt(MpcCore.div(a, b)) == -4, "int256 div");
+        require(MpcCore.decrypt(MpcCore.checkedAdd(a, b)) == -9, "int256 checked add");
+        require(MpcCore.decrypt(MpcCore.checkedSub(a, b)) == -15, "int256 checked sub");
+        require(MpcCore.decrypt(MpcCore.checkedMul(a, b)) == -36, "int256 checked mul");
+    }
+
+    function basicSigned256ComparisonTest() public {
+        gtInt256 a = MpcCore.setPublic256(int256(-12));
+        gtInt256 b = MpcCore.setPublic256(int256(3));
+        gtInt256 sameA = MpcCore.setPublic256(int256(-12));
+
+        require(MpcCore.decrypt(MpcCore.eq(a, sameA)), "int256 eq");
+        require(MpcCore.decrypt(MpcCore.ne(a, b)), "int256 ne");
+        require(MpcCore.decrypt(MpcCore.lt(a, b)), "int256 lt");
+        require(MpcCore.decrypt(MpcCore.le(a, sameA)), "int256 le");
+        require(MpcCore.decrypt(MpcCore.gt(b, a)), "int256 gt");
+        require(MpcCore.decrypt(MpcCore.ge(sameA, a)), "int256 ge");
+    }
+
+    function basicSigned256MuxAndHelpersTest() public {
+        gtInt256 a = MpcCore.setPublic256(int256(-12));
+        gtInt256 b = MpcCore.setPublic256(int256(3));
+
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(true), a, b)) == 3, "int256 mux true");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(false), a, b)) == -12, "int256 mux false");
+        require(MpcCore.decrypt(MpcCore.toSigned(MpcCore.fromSigned(a))) == -12, "int256 conversion");
+        require(MpcCore.decrypt(MpcCore.negate(a)) == 12, "int256 negate");
+        require(MpcCore.int64ToUint64(-1) == type(uint64).max, "int64 to uint64");
+        require(MpcCore.uint64ToInt64(type(uint64).max) == -1, "uint64 to int64");
+    }
+
+    function minDivMinusOne256Test() public {
+        require(
+            MpcCore.decrypt(MpcCore.div(MpcCore.setPublic256(type(int256).min), MpcCore.setPublic256(int256(-1))))
+                == type(int256).min,
+            "int256 min div -1"
+        );
+    }
+
+    function plainMul256WrapTest() public {
+        require(
+            MpcCore.decrypt(MpcCore.mul(MpcCore.setPublic256(int256(1) << 128), MpcCore.setPublic256(int256(1) << 128)))
+                == 0,
+            "int256 mul wrap"
+        );
+    }
+}

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

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/// @dev Narrow signed widths (8/16/32/64) — split from ArithmeticSigned256TestsContract for EIP-170.
+contract ArithmeticSignedNarrowTestsContract {
+    function basicSigned8Test() public {
+        gtInt8 a = MpcCore.setPublic8(int8(-12));
+        gtInt8 b = MpcCore.setPublic8(int8(3));
+        gtInt8 sameA = MpcCore.setPublic8(int8(-12));
+
+        require(MpcCore.decrypt(MpcCore.add(a, b)) == -9, "int8 add");
+        require(MpcCore.decrypt(MpcCore.sub(a, b)) == -15, "int8 sub");
+        require(MpcCore.decrypt(MpcCore.mul(a, b)) == -36, "int8 mul");
+        require(MpcCore.decrypt(MpcCore.div(a, b)) == -4, "int8 div");
+        require(MpcCore.decrypt(MpcCore.checkedAdd(a, b)) == -9, "int8 checked add");
+        require(MpcCore.decrypt(MpcCore.checkedSub(a, b)) == -15, "int8 checked sub");
+        require(MpcCore.decrypt(MpcCore.checkedMul(a, b)) == -36, "int8 checked mul");
+        require(MpcCore.decrypt(MpcCore.eq(a, sameA)), "int8 eq");
+        require(MpcCore.decrypt(MpcCore.ne(a, b)), "int8 ne");
+        require(MpcCore.decrypt(MpcCore.lt(a, b)), "int8 lt");
+        require(MpcCore.decrypt(MpcCore.le(a, sameA)), "int8 le");
+        require(MpcCore.decrypt(MpcCore.gt(b, a)), "int8 gt");
+        require(MpcCore.decrypt(MpcCore.ge(sameA, a)), "int8 ge");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(true), a, b)) == 3, "int8 mux true");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(false), a, b)) == -12, "int8 mux false");
+        require(MpcCore.decrypt(MpcCore.shl(MpcCore.setPublic8(int8(-8)), 1)) == -16, "int8 shl");
+        require(MpcCore.decrypt(MpcCore.shr(MpcCore.setPublic8(int8(-8)), 1)) == -4, "int8 shr");
+    }
+
+    function basicSigned16Test() public {
+        gtInt16 a = MpcCore.setPublic16(int16(-12));
+        gtInt16 b = MpcCore.setPublic16(int16(3));
+        gtInt16 sameA = MpcCore.setPublic16(int16(-12));
+
+        require(MpcCore.decrypt(MpcCore.add(a, b)) == -9, "int16 add");
+        require(MpcCore.decrypt(MpcCore.sub(a, b)) == -15, "int16 sub");
+        require(MpcCore.decrypt(MpcCore.mul(a, b)) == -36, "int16 mul");
+        require(MpcCore.decrypt(MpcCore.div(a, b)) == -4, "int16 div");
+        require(MpcCore.decrypt(MpcCore.checkedAdd(a, b)) == -9, "int16 checked add");
+        require(MpcCore.decrypt(MpcCore.checkedSub(a, b)) == -15, "int16 checked sub");
+        require(MpcCore.decrypt(MpcCore.checkedMul(a, b)) == -36, "int16 checked mul");
+        require(MpcCore.decrypt(MpcCore.eq(a, sameA)), "int16 eq");
+        require(MpcCore.decrypt(MpcCore.ne(a, b)), "int16 ne");
+        require(MpcCore.decrypt(MpcCore.lt(a, b)), "int16 lt");
+        require(MpcCore.decrypt(MpcCore.le(a, sameA)), "int16 le");
+        require(MpcCore.decrypt(MpcCore.gt(b, a)), "int16 gt");
+        require(MpcCore.decrypt(MpcCore.ge(sameA, a)), "int16 ge");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(true), a, b)) == 3, "int16 mux true");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(false), a, b)) == -12, "int16 mux false");
+        require(MpcCore.decrypt(MpcCore.shl(MpcCore.setPublic16(int16(-8)), 1)) == -16, "int16 shl");
+        require(MpcCore.decrypt(MpcCore.shr(MpcCore.setPublic16(int16(-8)), 1)) == -4, "int16 shr");
+    }
+
+    function basicSigned32Test() public {
+        gtInt32 a = MpcCore.setPublic32(int32(-12));
+        gtInt32 b = MpcCore.setPublic32(int32(3));
+        gtInt32 sameA = MpcCore.setPublic32(int32(-12));
+
+        require(MpcCore.decrypt(MpcCore.add(a, b)) == -9, "int32 add");
+        require(MpcCore.decrypt(MpcCore.sub(a, b)) == -15, "int32 sub");
+        require(MpcCore.decrypt(MpcCore.mul(a, b)) == -36, "int32 mul");
+        require(MpcCore.decrypt(MpcCore.div(a, b)) == -4, "int32 div");
+        require(MpcCore.decrypt(MpcCore.checkedAdd(a, b)) == -9, "int32 checked add");
+        require(MpcCore.decrypt(MpcCore.checkedSub(a, b)) == -15, "int32 checked sub");
+        require(MpcCore.decrypt(MpcCore.checkedMul(a, b)) == -36, "int32 checked mul");
+        require(MpcCore.decrypt(MpcCore.eq(a, sameA)), "int32 eq");
+        require(MpcCore.decrypt(MpcCore.ne(a, b)), "int32 ne");
+        require(MpcCore.decrypt(MpcCore.lt(a, b)), "int32 lt");
+        require(MpcCore.decrypt(MpcCore.le(a, sameA)), "int32 le");
+        require(MpcCore.decrypt(MpcCore.gt(b, a)), "int32 gt");
+        require(MpcCore.decrypt(MpcCore.ge(sameA, a)), "int32 ge");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(true), a, b)) == 3, "int32 mux true");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(false), a, b)) == -12, "int32 mux false");
+        require(MpcCore.decrypt(MpcCore.shl(MpcCore.setPublic32(int32(-8)), 1)) == -16, "int32 shl");
+        require(MpcCore.decrypt(MpcCore.shr(MpcCore.setPublic32(int32(-8)), 1)) == -4, "int32 shr");
+    }
+
+    function basicSigned64Test() public {
+        gtInt64 a = MpcCore.setPublic64(int64(-12));
+        gtInt64 b = MpcCore.setPublic64(int64(3));
+        gtInt64 sameA = MpcCore.setPublic64(int64(-12));
+
+        require(MpcCore.decrypt(MpcCore.add(a, b)) == -9, "int64 add");
+        require(MpcCore.decrypt(MpcCore.sub(a, b)) == -15, "int64 sub");
+        require(MpcCore.decrypt(MpcCore.mul(a, b)) == -36, "int64 mul");
+        require(MpcCore.decrypt(MpcCore.div(a, b)) == -4, "int64 div");
+        require(MpcCore.decrypt(MpcCore.checkedAdd(a, b)) == -9, "int64 checked add");
+        require(MpcCore.decrypt(MpcCore.checkedSub(a, b)) == -15, "int64 checked sub");
+        require(MpcCore.decrypt(MpcCore.checkedMul(a, b)) == -36, "int64 checked mul");
+        require(MpcCore.decrypt(MpcCore.eq(a, sameA)), "int64 eq");
+        require(MpcCore.decrypt(MpcCore.ne(a, b)), "int64 ne");
+        require(MpcCore.decrypt(MpcCore.lt(a, b)), "int64 lt");
+        require(MpcCore.decrypt(MpcCore.le(a, sameA)), "int64 le");
+        require(MpcCore.decrypt(MpcCore.gt(b, a)), "int64 gt");
+        require(MpcCore.decrypt(MpcCore.ge(sameA, a)), "int64 ge");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(true), a, b)) == 3, "int64 mux true");
+        require(MpcCore.decrypt(MpcCore.mux(MpcCore.setPublic(false), a, b)) == -12, "int64 mux false");
+        require(MpcCore.decrypt(MpcCore.shl(MpcCore.setPublic64(int64(-8)), 1)) == -16, "int64 shl");
+        require(MpcCore.decrypt(MpcCore.shr(MpcCore.setPublic64(int64(-8)), 1)) == -4, "int64 shr");
+    }
+
+    function minDivMinusOne8Test() public {
+        require(
+            MpcCore.decrypt(MpcCore.div(MpcCore.setPublic8(type(int8).min), MpcCore.setPublic8(int8(-1))))
+                == type(int8).min,
+            "int8 min div -1"
+        );
+    }
+
+    function checkedAdd8OverflowTest() public {
+        MpcCore.checkedAdd(MpcCore.setPublic8(type(int8).max), MpcCore.setPublic8(int8(1)));
+    }
+
+    function checkedSub8UnderflowTest() public {
+        MpcCore.checkedSub(MpcCore.setPublic8(type(int8).min), MpcCore.setPublic8(int8(1)));
+    }
+
+    function checkedMul8OverflowTest() public {
+        MpcCore.checkedMul(MpcCore.setPublic8(int8(64)), MpcCore.setPublic8(int8(2)));
+    }
+}

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

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract ArithmeticSubTestsContract {
+
+    struct AllGTCastingValues {
+        gtUint8 a8_s;
+        gtUint8 b8_s;
+        gtUint16 a16_s;
+        gtUint16 b16_s;
+        gtUint32 a32_s;
+        gtUint32 b32_s;
+        gtUint64 a64_s;
+        gtUint64 b64_s;
+    }
+
+    struct Check16 {
+        gtUint16 res16_16;
+        gtUint16 res8_16;
+        gtUint16 res16_8;
+    }
+
+    struct Check32 {
+        gtUint32 res32_32;
+        gtUint32 res8_32;
+        gtUint32 res32_8;
+        gtUint32 res16_32;
+        gtUint32 res32_16;
+    }
+
+    struct Check64 {
+        gtUint64 res64_64;
+        gtUint64 res8_64;
+        gtUint64 res64_8;
+        gtUint64 res16_64;
+        gtUint64 res64_16;
+        gtUint64 res32_64;
+        gtUint64 res64_32;
+    }
+
+    uint8 subResult;
+
+    function getSubResult() public view returns (uint8) {
+        return subResult;
+    }
+
+    function setPublicValues(AllGTCastingValues memory castingValues, uint8 a, uint8 b) public{
+        castingValues.a8_s = MpcCore.setPublic8(a);
+        castingValues.b8_s = MpcCore.setPublic8(b);
+        castingValues.a16_s =  MpcCore.setPublic16(a);
+        castingValues.b16_s =  MpcCore.setPublic16(b);
+        castingValues.a32_s =  MpcCore.setPublic32(a);
+        castingValues.b32_s =  MpcCore.setPublic32(b);
+        castingValues.a64_s =  MpcCore.setPublic64(a);
+        castingValues.b64_s =  MpcCore.setPublic64(b);
+    }
+
+    function decryptAndCompareResults16(Check16 memory check16) public returns (uint16){
+
+        // Calculate the result
+        uint16 result = MpcCore.decrypt(check16.res16_16);
+
+        require(result == MpcCore.decrypt(check16.res8_16) && result == MpcCore.decrypt(check16.res16_8),
+            "decryptAndCompareAllResults: Failed to decrypt and compare all results");
+        return result;
+    }
+
+    function decryptAndCompareResults32(Check32 memory check32) public returns (uint32){
+
+        // Calculate the result
+        uint32 result = MpcCore.decrypt(check32.res32_32);
+
+        require(result == MpcCore.decrypt(check32.res8_32) && result == MpcCore.decrypt(check32.res32_8)
+        && result == MpcCore.decrypt(check32.res32_16) && result == MpcCore.decrypt(check32.res16_32),
+            "decryptAndCompareAllResults: Failed to decrypt and compare all results");
+
+        return result;
+    }
+
+    function decryptAndCompareResults64(Check64 memory check64) public returns (uint64){
+
+        // Calculate the result
+        uint64 result = MpcCore.decrypt(check64.res64_64);
+
+        require(result == MpcCore.decrypt(check64.res8_64) && result == MpcCore.decrypt(check64.res64_8)
+        && result == MpcCore.decrypt(check64.res64_16) && result == MpcCore.decrypt(check64.res16_64)
+        && result == MpcCore.decrypt(check64.res64_32) && result == MpcCore.decrypt(check64.res32_64),
+            "decryptAndCompareAllResults: Failed to decrypt and compare all results");
+
+        return result;
+    }
+
+    function subTest(uint8 a, uint8 b) public returns (uint8) {
+        AllGTCastingValues memory castingValues;
+        Check16 memory check16;
+        Check32 memory check32;
+        Check64 memory check64;
+        setPublicValues(castingValues, a, b);
+
+        // Calculate the expected result
+        uint8 result =  MpcCore.decrypt(MpcCore.sub(castingValues.a8_s, castingValues.b8_s));
+        subResult = result;
+
+        // Calculate the results with casting to 16
+        check16.res16_16 = MpcCore.sub(castingValues.a16_s, castingValues.b16_s);
+        check16.res8_16 = MpcCore.sub(castingValues.a8_s, castingValues.b16_s);
+        check16.res16_8 = MpcCore.sub(castingValues.a16_s, castingValues.b8_s);
+        uint16 res16 = decryptAndCompareResults16(check16);
+        require(res16 == result, "subTest: cast 16 failed");
+
+        // Calculate the result with casting to 32
+        check32.res32_32 = MpcCore.sub(castingValues.a32_s, castingValues.b32_s);
+        check32.res8_32 = MpcCore.sub(castingValues.a8_s, castingValues.b32_s);
+        check32.res32_8 = MpcCore.sub(castingValues.a32_s, castingValues.b8_s);
+        check32.res16_32 = MpcCore.sub(castingValues.a16_s, castingValues.b32_s);
+        check32.res32_16 = MpcCore.sub(castingValues.a32_s, castingValues.b16_s);
+        uint32 res32 = decryptAndCompareResults32(check32);
+        require(result == res32, "subTest: cast 32 failed");
+
+        // Calculate the result with casting to 64
+        check64.res64_64 = MpcCore.sub(castingValues.a64_s, castingValues.b64_s);
+        check64.res8_64 = MpcCore.sub(castingValues.a8_s, castingValues.b64_s);
+        check64.res64_8 = MpcCore.sub(castingValues.a64_s, castingValues.b8_s);
+        check64.res16_64 = MpcCore.sub(castingValues.a16_s, castingValues.b64_s);
+        check64.res64_16 = MpcCore.sub(castingValues.a64_s, castingValues.b16_s);
+        check64.res32_64 = MpcCore.sub(castingValues.a32_s, castingValues.b64_s);
+        check64.res64_32 = MpcCore.sub(castingValues.a64_s, castingValues.b32_s);
+        uint64 res64 = decryptAndCompareResults64(check64);
+        require(result == res64, "subTest: cast 64 failed");
+
+        // Check the result with scalar
+        require(result == MpcCore.decrypt(MpcCore.sub(a, castingValues.b8_s)) && result == MpcCore.decrypt(MpcCore.sub(castingValues.a8_s, b)),
+            "subTest: test 8 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.sub(a, castingValues.b16_s)) && result == MpcCore.decrypt(MpcCore.sub(castingValues.a16_s, b)),
+            "subTest: test 16 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.sub(a, castingValues.b32_s)) && result == MpcCore.decrypt(MpcCore.sub(castingValues.a32_s, b)),
+            "subTest: test 32 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.sub(a, castingValues.b64_s)) && result == MpcCore.decrypt(MpcCore.sub(castingValues.a64_s, b)),
+            "subTest: test 64 bits with scalar failed");
+
+        return result;
+    }
+
+    function checkedSubTest(uint8 a, uint8 b) public returns (uint8) {
+        AllGTCastingValues memory castingValues;
+        Check16 memory check16;
+        Check32 memory check32;
+        Check64 memory check64;
+        setPublicValues(castingValues, a, b);
+
+        // Calculate the expected result
+        uint8 result =  MpcCore.decrypt(MpcCore.checkedSub(castingValues.a8_s, castingValues.b8_s));
+        subResult = result;
+
+        // Calculate the results with casting to 16
+        check16.res16_16 = MpcCore.checkedSub(castingValues.a16_s, castingValues.b16_s);
+        check16.res8_16 = MpcCore.checkedSub(castingValues.a8_s, castingValues.b16_s);
+        check16.res16_8 = MpcCore.checkedSub(castingValues.a16_s, castingValues.b8_s);
+        uint16 res16 = decryptAndCompareResults16(check16);
+        require(res16 == result, "subTest: cast 16 failed");
+
+        // Calculate the result with casting to 32
+        check32.res32_32 = MpcCore.checkedSub(castingValues.a32_s, castingValues.b32_s);
+        check32.res8_32 = MpcCore.checkedSub(castingValues.a8_s, castingValues.b32_s);
+        check32.res32_8 = MpcCore.checkedSub(castingValues.a32_s, castingValues.b8_s);
+        check32.res16_32 = MpcCore.checkedSub(castingValues.a16_s, castingValues.b32_s);
+        check32.res32_16 = MpcCore.checkedSub(castingValues.a32_s, castingValues.b16_s);
+        uint32 res32 = decryptAndCompareResults32(check32);
+        require(result == res32, "subTest: cast 32 failed");
+
+        // Calculate the result with casting to 64
+        check64.res64_64 = MpcCore.checkedSub(castingValues.a64_s, castingValues.b64_s);
+        check64.res8_64 = MpcCore.checkedSub(castingValues.a8_s, castingValues.b64_s);
+        check64.res64_8 = MpcCore.checkedSub(castingValues.a64_s, castingValues.b8_s);
+        check64.res16_64 = MpcCore.checkedSub(castingValues.a16_s, castingValues.b64_s);
+        check64.res64_16 = MpcCore.checkedSub(castingValues.a64_s, castingValues.b16_s);
+        check64.res32_64 = MpcCore.checkedSub(castingValues.a32_s, castingValues.b64_s);
+        check64.res64_32 = MpcCore.checkedSub(castingValues.a64_s, castingValues.b32_s);
+        uint64 res64 = decryptAndCompareResults64(check64);
+        require(result == res64, "subTest: cast 64 failed");
+
+        // Check the result with scalar
+        require(result == MpcCore.decrypt(MpcCore.checkedSub(a, castingValues.b8_s)) && result == MpcCore.decrypt(MpcCore.checkedSub(castingValues.a8_s, b)),
+            "subTest: test 8 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.checkedSub(a, castingValues.b16_s)) && result == MpcCore.decrypt(MpcCore.checkedSub(castingValues.a16_s, b)),
+            "subTest: test 16 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.checkedSub(a, castingValues.b32_s)) && result == MpcCore.decrypt(MpcCore.checkedSub(castingValues.a32_s, b)),
+            "subTest: test 32 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.checkedSub(a, castingValues.b64_s)) && result == MpcCore.decrypt(MpcCore.checkedSub(castingValues.a64_s, b)),
+            "subTest: test 64 bits with scalar failed");
+
+        return result;
+    }
+}

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 /**
  * @title MinimalProxy

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";
 

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import "../../../utils/mpc/MpcCore.sol";