@coti-io/coti-contracts 0.1.0

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

@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Miscellaneous1TestsContract {
+
+    uint64 random = 0;
+    bool andRes;
+    bool orRes;
+    bool xorRes;
+    bool notRes;
+    bool eqRes;
+    bool neqRes;
+    bool muxRes;
+    bool onboardRes;
+
+    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
+        );
+    }
+
+    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 {
+        // 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 randomTest() public returns (uint64) {
+        return randTest_(false, 0);
+    }
+
+    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"
+            );
+        }
+    }
+
+    function randomBoundedTest(uint8 numBits) public returns (uint64) {
+        return randTest_(true, numBits);
+    }
+
+    function randTest_(bool isBounded, uint8 numBits) public returns (uint64) {
+        uint size = MAX_SIZE_8_BITS;
+        uint64[MAX_SIZE_8_BITS] memory randoms;
+        // Generate gtUint8 randoms
+        for (uint i = 0; i < size; i++) {
+            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);
+        }
+        // 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) {
+            size = MAX_SIZE_16_BITS;
+        }
+        // Generate gtUint16 randoms
+        for (uint i = 0; i < size; i++) {
+            if (!isBounded) {
+                randoms[i] = MpcCore.decrypt(MpcCore.rand16());
+            } else {
+                randoms[i] = MpcCore.decrypt(
+                    MpcCore.randBoundedBits16(numBits)
+                );
+            }
+        }
+        if (isBounded) {
+            // Check that all randoms are in bounds
+            checkBound(randoms, size, numBits);
+        }
+        // Check that not all the generated random values are the same
+        checkNotAllEqual(randoms, size);
+
+        // Generate gtUint32 randoms
+        if (!isBounded) {
+            size = MAX_SIZE_32_BITS;
+        }
+        for (uint i = 0; i < size; i++) {
+            if (!isBounded) {
+                randoms[i] = MpcCore.decrypt(MpcCore.rand32());
+            } else {
+                randoms[i] = MpcCore.decrypt(
+                    MpcCore.randBoundedBits32(numBits)
+                );
+            }
+        }
+        if (isBounded) {
+            // Check that all randoms are in bounds
+            checkBound(randoms, size, numBits);
+        }
+        // Check that not all the generated random values are the same
+        checkNotAllEqual(randoms, size);
+
+        // Generate gtUint64 randoms
+        if (!isBounded) {
+            size = MAX_SIZE_64_BITS;
+        }
+        for (uint i = 0; i < size; i++) {
+            if (!isBounded) {
+                randoms[i] = MpcCore.decrypt(MpcCore.rand64());
+            } else {
+                randoms[i] = MpcCore.decrypt(
+                    MpcCore.randBoundedBits64(numBits)
+                );
+            }
+        }
+        if (isBounded) {
+            // Check that all randoms are in bounds
+            checkBound(randoms, size, numBits);
+        }
+        // Check that not all the generated random values are the same
+        checkNotAllEqual(randoms, size);
+
+        return random;
+    }
+
+    function booleanTest(bool a, bool b, bool bit) public {
+        gtBool aGT = MpcCore.setPublic(a);
+        gtBool bGT = MpcCore.setPublic(b);
+        gtBool bitGT = MpcCore.setPublic(bit);
+
+        andRes = MpcCore.decrypt(MpcCore.and(aGT, bGT));
+        orRes = MpcCore.decrypt(MpcCore.or(aGT, bGT));
+        xorRes = MpcCore.decrypt(MpcCore.xor(aGT, bGT));
+        notRes = MpcCore.decrypt(MpcCore.not(aGT));
+        eqRes = MpcCore.decrypt(MpcCore.eq(aGT, bGT));
+        neqRes = MpcCore.decrypt(MpcCore.ne(aGT, bGT));
+        muxRes = MpcCore.decrypt(MpcCore.mux(bitGT, aGT, bGT));
+
+        ctBool cipher = MpcCore.offBoard(aGT);
+        onboardRes = MpcCore.decrypt(MpcCore.onBoard(cipher));
+    }
+}

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

@@ -0,0 +1,448 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Miscellaneous2TestsContract {
+
+    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 result;
+    bool boolResult;
+
+    function getResult() public view returns (uint8) {
+        return result;
+    }
+
+    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
+        result = MpcCore.decrypt(
+            MpcCore.div(castingValues.a8_s, castingValues.b8_s)
+        );
+
+        // 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
+        result = MpcCore.decrypt(
+            MpcCore.rem(castingValues.a8_s, castingValues.b8_s)
+        );
+
+        // 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
+        result = MpcCore.decrypt(
+            MpcCore.mux(selectionBit_s, castingValues.a8_s, castingValues.b8_s)
+        );
+
+        // 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");
+
+        return result;
+    }
+
+    function offboardOnboardTest(
+        uint8 a8,
+        uint16 a16,
+        uint32 a32,
+        uint32 a64
+    ) public returns (uint8) {
+        gtUint8 a8_s = MpcCore.setPublic8(a8);
+        gtUint16 a16_s = MpcCore.setPublic16(a16);
+        gtUint32 a32_s = MpcCore.setPublic32(a32);
+        gtUint64 a64_s = MpcCore.setPublic64(a64);
+
+        ctUint8 cipher8 = MpcCore.offBoard(a8_s);
+        result = MpcCore.decrypt(MpcCore.onBoard(cipher8));
+
+        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 == result16 && result == result32 && result == result64,
+            "Failed to offboard and onboard all values"
+        );
+
+        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/OffboardToUserKeyTestsContract.sol

@@ -0,0 +1,81 @@
+
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract OffboardToUserKeyTestContract {
+
+    bytes userKey;
+    uint8 x;
+    ctUint8 ctUserKey;
+
+    uint256 ct8;
+    uint256 ct16;
+    uint256 ct32;
+    uint256 ct64;
+
+    event AccountOnboarded(address indexed _from, bytes userKey);
+
+    function getCTs() public view returns (uint256, uint256, uint256, uint256) {
+        return (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
+        userKey = 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 getUserKey() public view returns (bytes memory) {
+        return userKey;
+    }
+
+    function getCt() public view returns (ctUint8) {
+        return ctUserKey;
+    }
+
+    function userKeyTest(
+        bytes calldata signedEK,
+        bytes calldata signature
+    ) public {
+        bytes memory encryptedKey = MpcCore.getUserKey(signedEK, signature);
+        emit AccountOnboarded(msg.sender, encryptedKey);
+    }
+
+    function offboardToUserTest(
+        uint8 a,
+        address addr
+    ) public returns (uint256, uint256, uint256, uint256) {
+        gtUint8 a8_s = MpcCore.setPublic8(a);
+        gtUint16 a16_s = MpcCore.setPublic16(a);
+        gtUint32 a32_s = MpcCore.setPublic32(a);
+        gtUint64 a64_s = MpcCore.setPublic64(a);
+
+        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);
+
+        ct8 = ctUint8.unwrap(cipher8);
+        ct16 = ctUint16.unwrap(cipher16);
+        ct32 = ctUint32.unwrap(cipher32);
+        ct64 = ctUint64.unwrap(cipher64);
+
+        return (ct8, ct16, ct32, ct64);
+    }
+}