@coti-io/coti-contracts 0.1.0 → 1.0.2

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

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-
 pragma solidity ^0.8.19;
 
 import "../../../utils/mpc/MpcCore.sol";
@@ -7,6 +6,7 @@ import "../../../utils/mpc/MpcCore.sol";
 contract Miscellaneous1TestsContract {
 
     uint64 random = 0;
+    uint64 randomBounded = 0;
     bool andRes;
     bool orRes;
     bool xorRes;
@@ -16,64 +16,60 @@ contract Miscellaneous1TestsContract {
     bool muxRes;
     bool onboardRes;
 
+    uint8 validateCiphertextRes;
+
     function getRandom() public view returns (uint64) {
         return random;
     }
 
-    function getBooleanResults()
-        public
-        view
-        returns (bool, bool, bool, bool, bool, bool, bool, bool)
-    {
-        return (
-            andRes,
-            orRes,
-            xorRes,
-            notRes,
-            eqRes,
-            neqRes,
-            muxRes,
-            onboardRes
-        );
+    function getRandomBounded() public view returns (uint64) {
+        return randomBounded;
+    }
+
+    function getBooleanResults() public view returns (bool, bool, bool, bool, bool, bool, bool, bool) {
+        return (andRes, orRes, xorRes, notRes, eqRes, neqRes, muxRes, onboardRes);
+    }
+
+    function getValidateCiphertextResult() public view returns (uint8) {
+        return validateCiphertextRes;
     }
 
+    uint constant MAX_SIZE_1_BIT = 10;
     uint constant MAX_SIZE_8_BITS = 10;
     uint constant MAX_SIZE_16_BITS = 3;
     uint constant MAX_SIZE_32_BITS = 3;
     uint constant MAX_SIZE_64_BITS = 2;
     uint constant MAX_BOOL_SIZE = 40;
 
-    function checkNotAllEqual(
-        uint64[MAX_SIZE_8_BITS] memory randoms,
-        uint size
-    ) private {
+    function checkNotAllEqual(bool[MAX_SIZE_1_BIT] memory randoms, uint size) private {
+        // Count how many randoms are equal
+        uint numEqual = 1;
+        for (uint i = 1; i < size; i++) {
+            if (randoms[0] == randoms[i]){
+                numEqual++;
+            }
+        }
+        require(numEqual != size, "randomTest: random failed, all values are the same");
+    }
+
+    function checkNotAllEqual(uint64[MAX_SIZE_8_BITS] memory randoms, uint size) private {
         // Count how many randoms are equal
         uint numEqual = 1;
         for (uint i = 1; i < size; i++) {
-            if (randoms[0] == randoms[i]) {
+            if (randoms[0] == randoms[i]){
                 numEqual++;
             }
         }
-        require(
-            numEqual != size,
-            "randomTest: random failed, all values are the same"
-        );
+        require(numEqual != size, "randomTest: random failed, all values are the same");
     }
 
     function randomTest() public returns (uint64) {
         return randTest_(false, 0);
     }
 
-    function checkBound(
-        uint64[MAX_SIZE_8_BITS] memory randoms,
-        uint size,
-        uint8 numBits
-    ) public {
+    function checkBound(uint64[MAX_SIZE_8_BITS] memory randoms, uint size, uint8 numBits) public {
         for (uint i = 0; i < size; i++) {
-            require(
-                randoms[i] < (1 << numBits),
-                "randomTest: random failed, out of bounds"
-            );
+            require(randoms[i] < (1 << numBits), "randomTest: random failed, out of bounds");
         }
     }
 
@@ -82,17 +78,37 @@ contract Miscellaneous1TestsContract {
     }
 
     function randTest_(bool isBounded, uint8 numBits) public returns (uint64) {
-        uint size = MAX_SIZE_8_BITS;
+        uint size = MAX_SIZE_1_BIT;
+        bool[MAX_SIZE_1_BIT] memory randomBools;
+        
+        if (!isBounded) {
+            // Generate gtBool randoms
+            for (uint i = 0; i < size; i++) {
+                randomBools[i] = MpcCore.decrypt(MpcCore.rand());
+            }
+
+            // Check that not all the generated random values are the same
+            checkNotAllEqual(randomBools, size);
+        }
+
         uint64[MAX_SIZE_8_BITS] memory randoms;
+
+        // In case of bounded random, the bit size does not matter because the bounded bits can be small.
+        // So the max size remain as in 8 bits.
+        // In case of unbounded random, max size can be reduced.
+        if (!isBounded){
+            size = MAX_SIZE_8_BITS;
+        }
+        
         // Generate gtUint8 randoms
         for (uint i = 0; i < size; i++) {
-            if (!isBounded) {
+            if(!isBounded){
                 randoms[i] = MpcCore.decrypt(MpcCore.rand8());
             } else {
                 randoms[i] = MpcCore.decrypt(MpcCore.randBoundedBits8(numBits));
             }
         }
-        random = randoms[0];
+
         if (isBounded) {
             // Check that all randoms are in bounds
             checkBound(randoms, size, numBits);
@@ -100,20 +116,15 @@ contract Miscellaneous1TestsContract {
         // Check that not all the generated random values are the same
         checkNotAllEqual(randoms, size);
 
-        // In case of bounded random, the bit size does not matter because the bounded bits can be small.
-        // So the max size remain as in 8 bits.
-        // In case of unbounded random, max size can be reduced.
-        if (!isBounded) {
+        if (!isBounded){
             size = MAX_SIZE_16_BITS;
         }
         // Generate gtUint16 randoms
         for (uint i = 0; i < size; i++) {
-            if (!isBounded) {
+            if(!isBounded){
                 randoms[i] = MpcCore.decrypt(MpcCore.rand16());
             } else {
-                randoms[i] = MpcCore.decrypt(
-                    MpcCore.randBoundedBits16(numBits)
-                );
+                randoms[i] = MpcCore.decrypt(MpcCore.randBoundedBits16(numBits));
             }
         }
         if (isBounded) {
@@ -124,16 +135,14 @@ contract Miscellaneous1TestsContract {
         checkNotAllEqual(randoms, size);
 
         // Generate gtUint32 randoms
-        if (!isBounded) {
+        if (!isBounded){
             size = MAX_SIZE_32_BITS;
         }
         for (uint i = 0; i < size; i++) {
-            if (!isBounded) {
+            if(!isBounded){
                 randoms[i] = MpcCore.decrypt(MpcCore.rand32());
             } else {
-                randoms[i] = MpcCore.decrypt(
-                    MpcCore.randBoundedBits32(numBits)
-                );
+                randoms[i] = MpcCore.decrypt(MpcCore.randBoundedBits32(numBits));
             }
         }
         if (isBounded) {
@@ -144,21 +153,23 @@ contract Miscellaneous1TestsContract {
         checkNotAllEqual(randoms, size);
 
         // Generate gtUint64 randoms
-        if (!isBounded) {
+        if (!isBounded){
             size = MAX_SIZE_64_BITS;
         }
         for (uint i = 0; i < size; i++) {
-            if (!isBounded) {
+            if(!isBounded){
                 randoms[i] = MpcCore.decrypt(MpcCore.rand64());
             } else {
-                randoms[i] = MpcCore.decrypt(
-                    MpcCore.randBoundedBits64(numBits)
-                );
+                randoms[i] = MpcCore.decrypt(MpcCore.randBoundedBits64(numBits));
             }
         }
+
         if (isBounded) {
             // Check that all randoms are in bounds
             checkBound(randoms, size, numBits);
+            randomBounded = randoms[0];
+        } else {
+            random = randoms[0];
         }
         // Check that not all the generated random values are the same
         checkNotAllEqual(randoms, size);
@@ -182,4 +193,40 @@ contract Miscellaneous1TestsContract {
         ctBool cipher = MpcCore.offBoard(aGT);
         onboardRes = MpcCore.decrypt(MpcCore.onBoard(cipher));
     }
-}
+
+    // When invoking this test function, all ciphertexts share the same value but are
+    // cast to four different types: ctUint8, ctUint16, ctUint32, and ctUint64.
+    // Consequently, there is a single signature covering all these ciphertexts.
+    function validateCiphertextTest(ctUint8 ct8, ctUint16 ct16, ctUint32 ct32, ctUint64 ct64, bytes calldata signature) public returns (uint8){
+        // Create ITs from ciphertext and signature
+        itUint8 memory it8;
+        it8.ciphertext = ct8;
+        it8.signature = signature;
+
+        itUint16 memory it16;
+        it16.ciphertext = ct16;
+        it16.signature = signature;
+
+        itUint32 memory it32;
+        it32.ciphertext = ct32;
+        it32.signature = signature;
+
+        itUint64 memory it64;
+        it64.ciphertext = ct64;
+        it64.signature = signature;
+
+        validateCiphertextRes = MpcCore.decrypt(MpcCore.validateCiphertext(it8));
+
+        uint16 result16 = MpcCore.decrypt(MpcCore.validateCiphertext(it16));
+        require(result16 == validateCiphertextRes, "validateCiphertextTest: validateCiphertext with 16 bits failed");
+
+        uint32 result32 = MpcCore.decrypt(MpcCore.validateCiphertext(it32));
+        require(result32 == validateCiphertextRes, "validateCiphertextTest: validateCiphertext with 32 bits failed");
+
+        uint64 result64 = MpcCore.decrypt(MpcCore.validateCiphertext(it64));
+        require(result64 == validateCiphertextRes, "validateCiphertextTest: validateCiphertext with 64 bits failed");
+
+        return validateCiphertextRes;
+    }
+
+}

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

@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract MiscellaneousTestsContract {
+
+    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;
+    }
+
+    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);
+    }
+
+    uint8 divResult;
+    uint8 remResult;
+    uint8 muxResult;
+    bool boolResult;
+
+    function getDivResult() public view returns (uint8) {
+        return divResult;
+    }
+    function getRemResult() public view returns (uint8) {
+        return remResult;
+    }
+    function getMuxResult() public view returns (uint8) {
+        return muxResult;
+    }
+
+    function getBoolResult() public view returns (bool) {
+        return boolResult;
+    }
+
+    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 divTest(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.div(castingValues.a8_s, castingValues.b8_s));
+        divResult = result;
+
+        // Calculate the results with casting to 16
+        check16.res16_16 = MpcCore.div(castingValues.a16_s, castingValues.b16_s);
+        check16.res8_16 = MpcCore.div(castingValues.a8_s, castingValues.b16_s);
+        check16.res16_8 = MpcCore.div(castingValues.a16_s, castingValues.b8_s);
+        uint16 res16 = decryptAndCompareResults16(check16);
+        require(res16 == result, "divTest: cast 16 failed");
+
+        // Calculate the result with casting to 32
+        check32.res32_32 = MpcCore.div(castingValues.a32_s, castingValues.b32_s);
+        check32.res8_32 = MpcCore.div(castingValues.a8_s, castingValues.b32_s);
+        check32.res32_8 = MpcCore.div(castingValues.a32_s, castingValues.b8_s);
+        check32.res16_32 = MpcCore.div(castingValues.a16_s, castingValues.b32_s);
+        check32.res32_16 = MpcCore.div(castingValues.a32_s, castingValues.b16_s);
+        uint32 res32 = decryptAndCompareResults32(check32);
+        require(result == res32, "divTest: cast 32 failed");
+
+        // Calculate the result with casting to 64
+        check64.res64_64 = MpcCore.div(castingValues.a64_s, castingValues.b64_s);
+        check64.res8_64 = MpcCore.div(castingValues.a8_s, castingValues.b64_s);
+        check64.res64_8 = MpcCore.div(castingValues.a64_s, castingValues.b8_s);
+        check64.res16_64 = MpcCore.div(castingValues.a16_s, castingValues.b64_s);
+        check64.res64_16 = MpcCore.div(castingValues.a64_s, castingValues.b16_s);
+        check64.res32_64 = MpcCore.div(castingValues.a32_s, castingValues.b64_s);
+        check64.res64_32 = MpcCore.div(castingValues.a64_s, castingValues.b32_s);
+        uint64 res64 = decryptAndCompareResults64(check64);
+        require(result == res64, "divTest: cast 64 failed");
+
+        // Check the result with scalar
+        require(result == MpcCore.decrypt(MpcCore.div(a, castingValues.b8_s)) && result == MpcCore.decrypt(MpcCore.div(castingValues.a8_s, b)),
+            "divTest: test 8 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.div(a, castingValues.b16_s)) && result == MpcCore.decrypt(MpcCore.div(castingValues.a16_s, b)),
+            "divTest: test 16 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.div(a, castingValues.b32_s)) && result == MpcCore.decrypt(MpcCore.div(castingValues.a32_s, b)),
+            "divTest: test 32 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.div(a, castingValues.b64_s)) && result == MpcCore.decrypt(MpcCore.div(castingValues.a64_s, b)),
+            "divTest: test 64 bits with scalar failed");
+
+        return result;
+    }
+
+    function remTest(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.rem(castingValues.a8_s, castingValues.b8_s));
+        remResult = result;
+
+        // Calculate the results with casting to 16
+        check16.res16_16 = MpcCore.rem(castingValues.a16_s, castingValues.b16_s);
+        check16.res8_16 = MpcCore.rem(castingValues.a8_s, castingValues.b16_s);
+        check16.res16_8 = MpcCore.rem(castingValues.a16_s, castingValues.b8_s);
+        uint16 res16 = decryptAndCompareResults16(check16);
+        require(res16 == result, "remTest: cast 16 failed");
+
+        // Calculate the result with casting to 32
+        check32.res32_32 = MpcCore.rem(castingValues.a32_s, castingValues.b32_s);
+        check32.res8_32 = MpcCore.rem(castingValues.a8_s, castingValues.b32_s);
+        check32.res32_8 = MpcCore.rem(castingValues.a32_s, castingValues.b8_s);
+        check32.res16_32 = MpcCore.rem(castingValues.a16_s, castingValues.b32_s);
+        check32.res32_16 = MpcCore.rem(castingValues.a32_s, castingValues.b16_s);
+        uint32 res32 = decryptAndCompareResults32(check32);
+        require(result == res32, "remTest: cast 32 failed");
+
+        // Calculate the result with casting to 64
+        check64.res64_64 = MpcCore.rem(castingValues.a64_s, castingValues.b64_s);
+        check64.res8_64 = MpcCore.rem(castingValues.a8_s, castingValues.b64_s);
+        check64.res64_8 = MpcCore.rem(castingValues.a64_s, castingValues.b8_s);
+        check64.res16_64 = MpcCore.rem(castingValues.a16_s, castingValues.b64_s);
+        check64.res64_16 = MpcCore.rem(castingValues.a64_s, castingValues.b16_s);
+        check64.res32_64 = MpcCore.rem(castingValues.a32_s, castingValues.b64_s);
+        check64.res64_32 = MpcCore.rem(castingValues.a64_s, castingValues.b32_s);
+        uint64 res64 = decryptAndCompareResults64(check64);
+        require(result == res64, "remTest: cast 64 failed");
+
+        // Check the result with scalar
+        require(result == MpcCore.decrypt(MpcCore.rem(a, castingValues.b8_s)) && result == MpcCore.decrypt(MpcCore.rem(castingValues.a8_s, b)),
+            "remTest: test 8 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.rem(a, castingValues.b16_s)) && result == MpcCore.decrypt(MpcCore.rem(castingValues.a16_s, b)),
+            "remTest: test 16 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.rem(a, castingValues.b32_s)) && result == MpcCore.decrypt(MpcCore.rem(castingValues.a32_s, b)),
+            "remTest: test 32 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.rem(a, castingValues.b64_s)) && result == MpcCore.decrypt(MpcCore.rem(castingValues.a64_s, b)),
+            "remTest: test 64 bits with scalar failed");
+
+        return result;
+    }
+
+    function muxTest(bool selectionBit, uint8 a, uint8 b) public returns (uint8) {
+        AllGTCastingValues memory castingValues;
+        Check16 memory check16;
+        Check32 memory check32;
+        Check64 memory check64;
+        setPublicValues(castingValues, a, b);
+        gtBool selectionBit_s = MpcCore.setPublic(selectionBit);
+
+        // Calculate the expected result
+        uint8 result =  MpcCore.decrypt(MpcCore.mux(selectionBit_s, castingValues.a8_s, castingValues.b8_s));
+        muxResult = result;
+
+        // Calculate the result with casting to 16
+        check16.res16_16 = MpcCore.mux(selectionBit_s, castingValues.a16_s, castingValues.b16_s);
+        check16.res8_16 = MpcCore.mux(selectionBit_s, castingValues.a8_s, castingValues.b16_s);
+        check16.res16_8 = MpcCore.mux(selectionBit_s, castingValues.a16_s, castingValues.b8_s);
+        uint16 res16 = decryptAndCompareResults16(check16);
+        require(res16 == result, "muxTest: cast 16 failed");
+
+        // Calculate the result with casting to 32
+        check32.res32_32 = MpcCore.mux(selectionBit_s, castingValues.a32_s, castingValues.b32_s);
+        check32.res8_32 = MpcCore.mux(selectionBit_s, castingValues.a8_s, castingValues.b32_s);
+        check32.res32_8 = MpcCore.mux(selectionBit_s, castingValues.a32_s, castingValues.b8_s);
+        check32.res16_32 = MpcCore.mux(selectionBit_s, castingValues.a16_s, castingValues.b32_s);
+        check32.res32_16 = MpcCore.mux(selectionBit_s, castingValues.a32_s, castingValues.b16_s);
+        uint32 res32 = decryptAndCompareResults32(check32);
+        require(result == res32, "muxTest: cast 32 failed");
+
+        // Calculate the result with casting to 64
+        check64.res64_64 = MpcCore.mux(selectionBit_s, castingValues.a64_s, castingValues.b64_s);
+        check64.res8_64 = MpcCore.mux(selectionBit_s, castingValues.a8_s, castingValues.b64_s);
+        check64.res64_8 = MpcCore.mux(selectionBit_s, castingValues.a64_s, castingValues.b8_s);
+        check64.res16_64 = MpcCore.mux(selectionBit_s, castingValues.a16_s, castingValues.b64_s);
+        check64.res64_16 = MpcCore.mux(selectionBit_s, castingValues.a64_s, castingValues.b16_s);
+        check64.res32_64 = MpcCore.mux(selectionBit_s, castingValues.a32_s, castingValues.b64_s);
+        check64.res64_32 = MpcCore.mux(selectionBit_s, castingValues.a64_s, castingValues.b32_s);
+        uint64 res64 = decryptAndCompareResults64(check64);
+        require(result == res64, "muxTest: cast 64 failed");
+
+        // Check the result with scalar
+        require(result == MpcCore.decrypt(MpcCore.mux(selectionBit_s, a, castingValues.b8_s)) && result == MpcCore.decrypt(MpcCore.mux(selectionBit_s, castingValues.a8_s, b)),
+            "muxTest: test 8 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.mux(selectionBit_s, a, castingValues.b16_s)) && result == MpcCore.decrypt(MpcCore.mux(selectionBit_s, castingValues.a16_s, b)),
+            "muxTest: test 16 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.mux(selectionBit_s, a, castingValues.b32_s)) && result == MpcCore.decrypt(MpcCore.mux(selectionBit_s, castingValues.a32_s, b)),
+            "muxTest: test 32 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.mux(selectionBit_s, a, castingValues.b64_s)) && result == MpcCore.decrypt(MpcCore.mux(selectionBit_s, castingValues.a64_s, b)),
+            "muxTest: test 64 bits with scalar failed");
+
+        return result;
+    }
+
+    function notTest(bool a) public returns (bool) {
+        gtBool a_s = MpcCore.setPublic(a);
+        gtBool not = MpcCore.not(a_s);
+        boolResult = MpcCore.decrypt(not);
+
+        return boolResult;
+    }
+
+}

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

@@ -0,0 +1,127 @@
+
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract OffboardToUserKeyTestContract {
+
+    bytes keyShare0;
+    bytes keyShare1;
+    uint8 x;
+    ctUint8 ctUserKey;
+
+    uint256 ct;
+    uint256 ct8;
+    uint256 ct16;
+    uint256 ct32;
+    uint256 ct64;
+
+    uint8 onboardOffboardResult;
+
+    function getOnboardOffboardResult() public view returns (uint8) {
+        return onboardOffboardResult;
+    }
+
+    function getCTs() public view returns (uint256, uint256, uint256, uint256, uint256) {
+        return (ct, ct8, ct16, ct32, ct64);
+    }
+
+    function getUserKeyTest(bytes calldata signedEK, bytes calldata signature, address addr) public returns (uint8) {
+
+        gtUint8 a = MpcCore.setPublic8(uint8(5));
+        gtUint8 c = MpcCore.add(a, uint8(5)); // 10
+        (keyShare0, keyShare1) = MpcCore.getUserKey(signedEK, signature);
+        ctUserKey = MpcCore.offBoardToUser(c, addr);
+        ctUint8 ctSystemKey = MpcCore.offBoard(c);
+        gtUint8 c1 = MpcCore.onBoard(ctSystemKey);
+        x = MpcCore.decrypt(c1);
+        return x;
+    }
+
+    function getX() public view returns (uint8) {
+        return x;
+    }
+
+    function getUserKeyShares() public view returns (bytes memory, bytes memory) {
+        return (keyShare0, keyShare1);
+    }
+
+    function getCt() public view returns (ctUint8) {
+        return ctUserKey;
+    }
+
+    function userKeyTest(bytes calldata signedEK, bytes calldata signature) public returns (bytes memory, bytes memory) {
+
+        (keyShare0, keyShare1) = MpcCore.getUserKey(signedEK, signature);
+        return (keyShare0, keyShare1);
+    }
+
+    function offboardToUserTest(uint8 a, address addr) public {
+        gtBool aBool_s = MpcCore.setPublic(a > 0);
+        gtUint8 a8_s = MpcCore.setPublic8(a);
+        gtUint16 a16_s = MpcCore.setPublic16(a);
+        gtUint32 a32_s = MpcCore.setPublic32(a);
+        gtUint64 a64_s = MpcCore.setPublic64(a);
+
+        ctBool cipherBool = MpcCore.offBoardToUser(aBool_s, addr);
+        ctUint8 cipher8 = MpcCore.offBoardToUser(a8_s, addr);
+        ctUint16 cipher16 = MpcCore.offBoardToUser(a16_s, addr);
+        ctUint32 cipher32 = MpcCore.offBoardToUser(a32_s, addr);
+        ctUint64 cipher64 = MpcCore.offBoardToUser(a64_s, addr);
+
+        ct = ctBool.unwrap(cipherBool);
+        ct8 = ctUint8.unwrap(cipher8);
+        ct16 = ctUint16.unwrap(cipher16);
+        ct32 = ctUint32.unwrap(cipher32);
+        ct64 = ctUint64.unwrap(cipher64);
+    }
+
+    function offboardCombinedTest(uint8 a, address addr) public {
+        gtBool aBool_s = MpcCore.setPublic(a > 0);
+        gtUint8 a8_s = MpcCore.setPublic8(a);
+        gtUint16 a16_s = MpcCore.setPublic16(a);
+        gtUint32 a32_s = MpcCore.setPublic32(a);
+        gtUint64 a64_s = MpcCore.setPublic64(a);
+
+        utBool memory cipherBool = MpcCore.offBoardCombined(aBool_s, addr);
+        utUint8 memory cipher8 = MpcCore.offBoardCombined(a8_s, addr);
+        utUint16 memory cipher16 = MpcCore.offBoardCombined(a16_s, addr);
+        utUint32 memory cipher32 = MpcCore.offBoardCombined(a32_s, addr);
+        utUint64 memory cipher64 = MpcCore.offBoardCombined(a64_s, addr);
+
+        ct = ctBool.unwrap(cipherBool.userCiphertext);
+        ct8 = ctUint8.unwrap(cipher8.userCiphertext);
+        ct16 = ctUint16.unwrap(cipher16.userCiphertext);
+        ct32 = ctUint32.unwrap(cipher32.userCiphertext);
+        ct64 = ctUint64.unwrap(cipher64.userCiphertext);
+    }
+
+    function offboardOnboardTest(uint8 a8, uint16 a16, uint32 a32, uint32 a64) public {
+        bool temp = a8 > 0;
+        gtBool aBool_s = MpcCore.setPublic(temp);
+        gtUint8 a8_s = MpcCore.setPublic8(a8);
+        gtUint16 a16_s = MpcCore.setPublic16(a16);
+        gtUint32 a32_s = MpcCore.setPublic32(a32);
+        gtUint64 a64_s = MpcCore.setPublic64(a64);
+
+        ctBool cipher = MpcCore.offBoard(aBool_s);
+        bool result = MpcCore.decrypt(MpcCore.onBoard(cipher));
+
+        ctUint8 cipher8 = MpcCore.offBoard(a8_s);
+        uint8 result8 = MpcCore.decrypt(MpcCore.onBoard(cipher8));
+        onboardOffboardResult = result8;
+
+        ctUint16 cipher16 = MpcCore.offBoard(a16_s);
+        uint16 result16 = MpcCore.decrypt(MpcCore.onBoard(cipher16));
+
+        ctUint32 cipher32 = MpcCore.offBoard(a32_s);
+        uint32 result32 = MpcCore.decrypt(MpcCore.onBoard(cipher32));
+
+        ctUint64 cipher64 = MpcCore.offBoard(a64_s);
+        uint64 result64 = MpcCore.decrypt(MpcCore.onBoard(cipher64));
+
+        require(result == temp && result8 == result16 && result8 == result32 && result8 == result64,
+            "Failed to offboard and onboard all values");
+    }
+}