@coti-io/coti-contracts 1.0.0 → 1.0.2

package/.github/workflows/npm-publish.yml

@@ -43,8 +43,9 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - uses: actions/setup-node@v3
         with:
-          node-version: 16
+          node-version: 18
           registry-url: https://registry.npmjs.org/
+          scope: '@coti-io'
       - run: npm ci
       - run: npm publish --access=public
         env:

package/CONTRIBUTING.md

@@ -1,7 +1,7 @@
 
-# Contributing to COTI SDK TypeScript Examples
+# Contributing to COTI Contracts
 
-Thank you for your interest in contributing to the COTI SDK TypeScript Examples project! We welcome contributions from the community and appreciate your efforts to improve our project.
+Thank you for your interest in contributing to the COTI Contracts project! We welcome contributions from the community and appreciate your efforts to improve our project.
 
 ## Table of Contents
 

package/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2024 COTI
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -1,48 +1,31 @@
-# COTI Contracts
-
-A library for smart contract development on the COTI network.
-
-> [!NOTE]
-> This repository is meant to replace the now-deprecated [confidentiality-contracts](https://github.com/coti-io/confidentiality-contracts) repository.
-
-#### Important Links
-
-[Docs](https://docs.coti.io) | [Discord](https://discord.gg/cuCykh8P4m) | [Faucet](https://faucet.coti.io)
-
-#### Network-Specific Links
+[![image](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://telegram.coti.io)
+[![image](https://img.shields.io/badge/Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.coti.io)
+[![image](https://img.shields.io/badge/X-000000?style=for-the-badge&logo=x&logoColor=white)](https://twitter.coti.io)
+[![image](https://img.shields.io/badge/YouTube-FF0000?style=for-the-badge&logo=youtube&logoColor=white)](https://youtube.coti.io)
 
-[Devnet Explorer](https://explorer-devnet.coti.io) | [Testnet Explorer](https://testnet.cotiscan.io)
+# COTI Contracts
 
-## Overview
+[![image](https://img.shields.io/badge/npm-CB3837?style=for-the-badge&logo=npm&logoColor=white)](https://www.npmjs.com/package/@coti-io/coti-contracts)
+[![image](https://img.shields.io/badge/Node%20js-339933?style=for-the-badge&logo=nodedotjs&logoColor=white)](https://nodejs.org/download/release/v18.20.5/)
 
-> [!NOTE]  
-> Due to the nature of ongoing development, future versions might break existing functionality
+Welcome to COTI Contracts, a library of smart contracts for COTI's GC technology, including MPC contract for secure computations, private ERC20 and ERC721 contracts, and test mocks for validation. These components enable privacy-focused and decentralized DeFi solutions.
 
-The following contracts are included in the library:
-- [DataPrivacyFramework](/contracts/access/DataPrivacyFramework/)
-- [AccountOnboard](/contracts/onboard/)
-- [PrivateERC20](/contracts/token/PrivateERC20/)
-- [PrivateERC721](/contracts/token/PrivateERC721/)
-- [MpcCore](/contracts/utils/mpc/)
+## Documentation
 
-### Installation
+Full API documentation is available in the [COTI docs](https://docs.coti.io/coti-v2-documentation/build-on-coti/tools/ethers.js)
 
-#### Hardhat (npm)
+## Build and Install
 
 ```bash
-npm install @coti-io/coti-contracts
+npm install
 ```
 
-### Usage
-
-Once installed, you can use the contracts in the library by importing them:
+## Testing
 
-```solidity
-pragma solidity ^0.8.20;
+```bash
+npx hardhat test
+```
 
-import {PrivateERC20} from "@coti-io/coti-contracts/token/PrivateERC20/PrivateERC20.sol";
+---
 
-contract MyToken is PrivateERC20 {
-    constructor() ERC721("MyToken", "MTOK") {}
-}
-```
+To report an issue, please see the [issues](https://github.com/coti-io/coti-contracts/issues/new) tab.

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

@@ -153,6 +153,57 @@ contract ArithmeticTestsContract {
         return result;
     }
 
+    function checkedAddTest(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.checkedAdd(castingValues.a8_s, castingValues.b8_s));
+        addResult = result;
+
+        // Calculate the results with casting to 16
+        check16.res16_16 = MpcCore.checkedAdd(castingValues.a16_s, castingValues.b16_s);
+        check16.res8_16 = MpcCore.checkedAdd(castingValues.a8_s, castingValues.b16_s);
+        check16.res16_8 = MpcCore.checkedAdd(castingValues.a16_s, castingValues.b8_s);
+        uint16 res16 = decryptAndCompareResults16(check16);
+        require(res16 == result, "addTest: cast 16 failed");
+
+        // Calculate the result with casting to 32
+        check32.res32_32 = MpcCore.checkedAdd(castingValues.a32_s, castingValues.b32_s);
+        check32.res8_32 = MpcCore.checkedAdd(castingValues.a8_s, castingValues.b32_s);
+        check32.res32_8 = MpcCore.checkedAdd(castingValues.a32_s, castingValues.b8_s);
+        check32.res16_32 = MpcCore.checkedAdd(castingValues.a16_s, castingValues.b32_s);
+        check32.res32_16 = MpcCore.checkedAdd(castingValues.a32_s, castingValues.b16_s);
+        uint32 res32 = decryptAndCompareResults32(check32);
+        require(result == res32, "addTest: cast 32 failed");
+
+        // Calculate the result with casting to 64
+        check64.res64_64 = MpcCore.checkedAdd(castingValues.a64_s, castingValues.b64_s);
+        check64.res8_64 = MpcCore.checkedAdd(castingValues.a8_s, castingValues.b64_s);
+        check64.res64_8 = MpcCore.checkedAdd(castingValues.a64_s, castingValues.b8_s);
+        check64.res16_64 = MpcCore.checkedAdd(castingValues.a16_s, castingValues.b64_s);
+        check64.res64_16 = MpcCore.checkedAdd(castingValues.a64_s, castingValues.b16_s);
+        check64.res32_64 = MpcCore.checkedAdd(castingValues.a32_s, castingValues.b64_s);
+        check64.res64_32 = MpcCore.checkedAdd(castingValues.a64_s, castingValues.b32_s);
+        uint64 res64 = decryptAndCompareResults64(check64);
+        require(result == res64, "addTest: cast 64 failed");
+
+        // Check the result with scalar
+        require(result == MpcCore.decrypt(MpcCore.checkedAdd(a, castingValues.b8_s)) && result == MpcCore.decrypt(MpcCore.checkedAdd(castingValues.a8_s, b)),
+            "addTest: test 8 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.checkedAdd(a, castingValues.b16_s)) && result == MpcCore.decrypt(MpcCore.checkedAdd(castingValues.a16_s, b)),
+            "addTest: test 16 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.checkedAdd(a, castingValues.b32_s)) && result == MpcCore.decrypt(MpcCore.checkedAdd(castingValues.a32_s, b)),
+            "addTest: test 32 bits with scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.checkedAdd(a, castingValues.b64_s)) && result == MpcCore.decrypt(MpcCore.checkedAdd(castingValues.a64_s, b)),
+            "addTest: test 64 bits with scalar failed");
+
+        return result;
+    }
+
     function subTest(uint8 a, uint8 b) public returns (uint8) {
         AllGTCastingValues memory castingValues;
         Check16 memory check16;
@@ -204,6 +255,57 @@ contract ArithmeticTestsContract {
         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;
+    }
+
     function mulTest(uint8 a, uint8 b) public returns (uint8) {
         AllGTCastingValues memory castingValues;
         Check16 memory check16;
@@ -253,4 +355,54 @@ contract ArithmeticTestsContract {
 
         return mulResult;
     }
+
+    function checkedMulTest(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
+        mulResult = MpcCore.decrypt(MpcCore.checkedMul(castingValues.a8_s, castingValues.b8_s));
+
+        // Calculate the result with casting to 16
+        check16.res16_16 = MpcCore.checkedMul(castingValues.a16_s, castingValues.b16_s);
+        check16.res8_16 = MpcCore.checkedMul(castingValues.a8_s, castingValues.b16_s);
+        check16.res16_8 = MpcCore.checkedMul(castingValues.a16_s, castingValues.b8_s);
+        uint16 res16 = decryptAndCompareResults16(check16);
+        require(mulResult == res16, "mulTest: cast 16 failed");
+
+        // Calculate the result with casting to 32
+        check32.res32_32 = MpcCore.checkedMul(castingValues.a32_s, castingValues.b32_s);
+        check32.res8_32 = MpcCore.checkedMul(castingValues.a8_s, castingValues.b32_s);
+        check32.res32_8 = MpcCore.checkedMul(castingValues.a32_s, castingValues.b8_s);
+        check32.res16_32 = MpcCore.checkedMul(castingValues.a16_s, castingValues.b32_s);
+        check32.res32_16 = MpcCore.checkedMul(castingValues.a32_s, castingValues.b16_s);
+        uint32 res32 = decryptAndCompareResults32(check32);
+        require(mulResult == res32, "mulTest: cast 32 failed");
+
+        // Calculate the result with casting to 64
+        check64.res64_64 = MpcCore.checkedMul(castingValues.a64_s, castingValues.b64_s);
+        check64.res8_64 = MpcCore.checkedMul(castingValues.a8_s, castingValues.b64_s);
+        check64.res64_8 = MpcCore.checkedMul(castingValues.a64_s, castingValues.b8_s);
+        check64.res16_64 = MpcCore.checkedMul(castingValues.a16_s, castingValues.b64_s);
+        check64.res64_16 = MpcCore.checkedMul(castingValues.a64_s, castingValues.b16_s);
+        check64.res32_64 = MpcCore.checkedMul(castingValues.a32_s, castingValues.b64_s);
+        check64.res64_32 = MpcCore.checkedMul(castingValues.a64_s, castingValues.b32_s);
+        uint64 res64 = decryptAndCompareResults64(check64);
+        require(mulResult == res64, "mulTest: cast 64 failed");
+
+        // Check the result with scalar
+        require(mulResult == MpcCore.decrypt(MpcCore.checkedMul(a, castingValues.b8_s)) && mulResult == MpcCore.decrypt(MpcCore.checkedMul(castingValues.a8_s, b)),
+            "mulTest: test 8 bits with scalar failed");
+        require(mulResult == MpcCore.decrypt(MpcCore.checkedMul(a, castingValues.b16_s)) && mulResult == MpcCore.decrypt(MpcCore.checkedMul(castingValues.a16_s, b)),
+            "mulTest: test 16 bits with scalar failed");
+        require(mulResult == MpcCore.decrypt(MpcCore.checkedMul(a, castingValues.b32_s)) && mulResult == MpcCore.decrypt(MpcCore.checkedMul(castingValues.a32_s, b)),
+            "mulTest: test 32 bits with scalar failed");
+        require(mulResult == MpcCore.decrypt(MpcCore.checkedMul(a, castingValues.b64_s)) && mulResult == MpcCore.decrypt(MpcCore.checkedMul(castingValues.a64_s, b)),
+            "mulTest: test 64 bits with scalar failed");
+
+        return mulResult;
+    }
 }

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

@@ -6,6 +6,8 @@ import "../../../utils/mpc/MpcCore.sol";
 contract BitwiseTestsContract {
 
     struct AllGTCastingValues {
+        gtBool aBool_s;
+        gtBool bBool_s;
         gtUint8 a8_s;
         gtUint8 b8_s;
         gtUint16 a16_s;
@@ -54,7 +56,9 @@ contract BitwiseTestsContract {
         return xorResult;
     }
 
-    function setPublicValues(AllGTCastingValues memory castingValues, uint8 a, uint8 b) public{
+    function setPublicValues(AllGTCastingValues memory castingValues, uint8 a, uint8 b) public {
+        castingValues.aBool_s = MpcCore.setPublic(a > b);
+        castingValues.bBool_s = MpcCore.setPublic(b > a);
         castingValues.a8_s = MpcCore.setPublic8(a);
         castingValues.b8_s = MpcCore.setPublic8(b);
         castingValues.a16_s =  MpcCore.setPublic16(a);
@@ -108,6 +112,8 @@ contract BitwiseTestsContract {
         Check64 memory check64;
         setPublicValues(castingValues, a, b);
 
+        MpcCore.decrypt(MpcCore.and(castingValues.aBool_s, castingValues.bBool_s));
+        
         // Calculate the expected result
         uint8 result =  MpcCore.decrypt(MpcCore.and(castingValues.a8_s, castingValues.b8_s));
         andResult = result;
@@ -159,6 +165,8 @@ contract BitwiseTestsContract {
         Check64 memory check64;
         setPublicValues(castingValues, a, b);
 
+        MpcCore.decrypt(MpcCore.or(castingValues.aBool_s, castingValues.bBool_s));
+
         // Calculate the expected result
         uint8 result =  MpcCore.decrypt(MpcCore.or(castingValues.a8_s, castingValues.b8_s));
         orResult = result;
@@ -210,6 +218,8 @@ contract BitwiseTestsContract {
         Check64 memory check64;
         setPublicValues(castingValues, a, b);
 
+        MpcCore.decrypt(MpcCore.xor(castingValues.aBool_s, castingValues.bBool_s));
+
         // Calculate the expected result
         uint8 result =  MpcCore.decrypt(MpcCore.xor(castingValues.a8_s, castingValues.b8_s));
         xorResult = result;

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

@@ -6,6 +6,8 @@ import "../../../utils/mpc/MpcCore.sol";
 contract Comparison2TestsContract {
 
     struct AllGTCastingValues {
+        gtBool aBool_s;
+        gtBool bBool_s;
         gtUint8 a8_s;
         gtUint8 b8_s;
         gtUint16 a16_s;
@@ -41,6 +43,8 @@ contract Comparison2TestsContract {
     }
 
     function setPublicValues(AllGTCastingValues memory castingValues, uint8 a, uint8 b) public{
+        castingValues.aBool_s = MpcCore.setPublic(a > b);
+        castingValues.bBool_s = MpcCore.setPublic(b > a);
         castingValues.a8_s = MpcCore.setPublic8(a);
         castingValues.b8_s = MpcCore.setPublic8(b);
         castingValues.a16_s =  MpcCore.setPublic16(a);
@@ -110,6 +114,8 @@ contract Comparison2TestsContract {
         Check64 memory check64;
         setPublicValues(castingValues, a, b);
 
+        MpcCore.decrypt(MpcCore.eq(castingValues.aBool_s, castingValues.bBool_s));
+
         // Calculate the expected result
         bool result =  MpcCore.decrypt(MpcCore.eq(castingValues.a8_s, castingValues.b8_s));
         eqResult = result;
@@ -161,6 +167,8 @@ contract Comparison2TestsContract {
         Check64 memory check64;
         setPublicValues(castingValues, a, b);
 
+        MpcCore.decrypt(MpcCore.ne(castingValues.aBool_s, castingValues.bBool_s));
+
         // Calculate the expected result
         bool result =  MpcCore.decrypt(MpcCore.ne(castingValues.a8_s, castingValues.b8_s));
         neResult = result;

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

@@ -34,12 +34,24 @@ contract Miscellaneous1TestsContract {
         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(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;
@@ -66,8 +78,28 @@ 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){
@@ -84,9 +116,6 @@ 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){
             size = MAX_SIZE_16_BITS;
         }

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

@@ -11,6 +11,7 @@ contract OffboardToUserKeyTestContract {
     uint8 x;
     ctUint8 ctUserKey;
 
+    uint256 ct;
     uint256 ct8;
     uint256 ct16;
     uint256 ct32;
@@ -22,8 +23,8 @@ contract OffboardToUserKeyTestContract {
         return onboardOffboardResult;
     }
 
-    function getCTs() public view returns (uint256, uint256, uint256, uint256) {
-        return (ct8, ct16, ct32, ct64);
+    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) {
@@ -56,34 +57,60 @@ contract OffboardToUserKeyTestContract {
         return (keyShare0, keyShare1);
     }
 
-    function offboardToUserTest(uint8 a, address addr) public returns (uint256, uint256, uint256, uint256) {
+    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);
 
-        return (ct8, ct16, ct32, ct64);
+        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 returns (uint8) {
+    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 result = MpcCore.decrypt(MpcCore.onBoard(cipher8));
-        onboardOffboardResult = result;
+        uint8 result8 = MpcCore.decrypt(MpcCore.onBoard(cipher8));
+        onboardOffboardResult = result8;
 
         ctUint16 cipher16 = MpcCore.offBoard(a16_s);
         uint16 result16 = MpcCore.decrypt(MpcCore.onBoard(cipher16));
@@ -94,9 +121,7 @@ contract OffboardToUserKeyTestContract {
         ctUint64 cipher64 = MpcCore.offBoard(a64_s);
         uint64 result64 = MpcCore.decrypt(MpcCore.onBoard(cipher64));
 
-        require(result == result16 && result == result32 && result == result64,
+        require(result == temp && result8 == result16 && result8 == result32 && result8 == result64,
             "Failed to offboard and onboard all values");
-
-        return result;
     }
 }

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

@@ -51,6 +51,9 @@ contract TransferTestsContract {
 
         (newA_s, newB_s, res_s) = MpcCore.transfer(allGTCastingValues.a16_s, allGTCastingValues.b8_s, allAmountValues.amount16_s);
         require(new_a == MpcCore.decrypt(newA_s) && new_b == MpcCore.decrypt(newB_s) && res == MpcCore.decrypt(res_s), "transferTest: cast 16 failed");
+
+        (newA_s, newB_s, res_s) = MpcCore.transfer(allGTCastingValues.a16_s, allGTCastingValues.b16_s, allAmountValues.amount8_s);
+        require(new_a == MpcCore.decrypt(newA_s) && new_b == MpcCore.decrypt(newB_s) && res == MpcCore.decrypt(res_s), "transferTest: cast 16 failed");
     }
 
     function computeAndCheckTransfer32(AllGTCastingValues memory allGTCastingValues, AllAmountValues memory allAmountValues, uint8 new_a, uint8 new_b, bool res) public {