@coti-io/coti-contracts 1.1.0 → 1.2.0

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

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract OnBoard128TestsContract {
+    uint128 onboardOffboardResult;
+    ctUint128 storedCiphertext;
+
+    function getOnboardOffboardResult() public view returns (uint128) {
+        return onboardOffboardResult;
+    }
+
+    function getStoredCiphertext() public view returns (ctUint128) {
+        return storedCiphertext;
+    }
+
+    /**
+     * @dev Test the round-trip: setPublic -> offBoard -> onBoard -> decrypt
+     * @param value The value to test
+     */
+    function testOnBoardOffBoardRoundTrip(uint128 value) public returns (uint128) {
+        // Step 1: Create garbled text from public value
+        gtUint128 gtValue = MpcCore.setPublic128(value);
+        
+        // Step 2: Convert garbled text to ciphertext (offBoard)
+        ctUint128 ciphertext = MpcCore.offBoard(gtValue);
+        storedCiphertext = ciphertext;
+        
+        // Step 3: Convert ciphertext back to garbled text (onBoard)
+        gtUint128 gtValue2 = MpcCore.onBoard(ciphertext);
+        
+        // Step 4: Decrypt to verify the value
+        uint128 result = MpcCore.decrypt(gtValue2);
+        onboardOffboardResult = result;
+        
+        require(result == value, "OnBoard/OffBoard round-trip failed");
+        
+        return result;
+    }
+
+    /**
+     * @dev Test onBoard with multiple values
+     */
+    function testOnBoardMultipleValues(uint128 a, uint128 b, uint128 c) public returns (uint128, uint128, uint128) {
+        // Test value A
+        gtUint128 gtA = MpcCore.setPublic128(a);
+        ctUint128 ctA = MpcCore.offBoard(gtA);
+        gtUint128 gtA2 = MpcCore.onBoard(ctA);
+        uint128 resultA = MpcCore.decrypt(gtA2);
+        require(resultA == a, "Value A test failed");
+        
+        // Test value B
+        gtUint128 gtB = MpcCore.setPublic128(b);
+        ctUint128 ctB = MpcCore.offBoard(gtB);
+        gtUint128 gtB2 = MpcCore.onBoard(ctB);
+        uint128 resultB = MpcCore.decrypt(gtB2);
+        require(resultB == b, "Value B test failed");
+        
+        // Test value C
+        gtUint128 gtC = MpcCore.setPublic128(c);
+        ctUint128 ctC = MpcCore.offBoard(gtC);
+        gtUint128 gtC2 = MpcCore.onBoard(ctC);
+        uint128 resultC = MpcCore.decrypt(gtC2);
+        require(resultC == c, "Value C test failed");
+        
+        return (resultA, resultB, resultC);
+    }
+
+    /**
+     * @dev Test onBoard with edge cases (0 and max)
+     */
+    function testOnBoardEdgeCases() public returns (uint128, uint128) {
+        // Test zero
+        uint128 zero = 0;
+        gtUint128 gtZero = MpcCore.setPublic128(zero);
+        ctUint128 ctZero = MpcCore.offBoard(gtZero);
+        gtUint128 gtZero2 = MpcCore.onBoard(ctZero);
+        uint128 resultZero = MpcCore.decrypt(gtZero2);
+        require(resultZero == zero, "Zero test failed");
+        
+        // Test max
+        uint128 max = type(uint128).max;
+        gtUint128 gtMax = MpcCore.setPublic128(max);
+        ctUint128 ctMax = MpcCore.offBoard(gtMax);
+        gtUint128 gtMax2 = MpcCore.onBoard(ctMax);
+        uint128 resultMax = MpcCore.decrypt(gtMax2);
+        require(resultMax == max, "Max test failed");
+        
+        return (resultZero, resultMax);
+    }
+}
+

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

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract OnBoard256TestsContract {
+    uint256 onboardOffboardResult;
+    ctUint256 storedCiphertext;
+
+    function getOnboardOffboardResult() public view returns (uint256) {
+        return onboardOffboardResult;
+    }
+
+    function getStoredCiphertext() public view returns (ctUint256 memory) {
+        return storedCiphertext;
+    }
+
+    /**
+     * @dev Test the round-trip: setPublic -> offBoard -> onBoard -> decrypt
+     * @param value The value to test
+     */
+    function testOnBoardOffBoardRoundTrip(uint256 value) public returns (uint256) {
+        // Step 1: Create garbled text from public value
+        gtUint256 gtValue = MpcCore.setPublic256(value);
+        
+        // Step 2: Convert garbled text to ciphertext (offBoard)
+        ctUint256 memory ciphertext = MpcCore.offBoard(gtValue);
+        storedCiphertext = ciphertext;
+        
+        // Step 3: Convert ciphertext back to garbled text (onBoard)
+        gtUint256 gtValue2 = MpcCore.onBoard(ciphertext);
+        
+        // Step 4: Decrypt to verify the value
+        uint256 result = MpcCore.decrypt(gtValue2);
+        onboardOffboardResult = result;
+        
+        require(result == value, "OnBoard/OffBoard round-trip failed");
+        
+        return result;
+    }
+
+    /**
+     * @dev Test onBoard with multiple values
+     */
+    function testOnBoardMultipleValues(uint256 a, uint256 b, uint256 c) public returns (uint256, uint256, uint256) {
+        // Test value A
+        gtUint256 gtA = MpcCore.setPublic256(a);
+        ctUint256 memory ctA = MpcCore.offBoard(gtA);
+        gtUint256 gtA2 = MpcCore.onBoard(ctA);
+        uint256 resultA = MpcCore.decrypt(gtA2);
+        require(resultA == a, "Value A test failed");
+        
+        // Test value B
+        gtUint256 gtB = MpcCore.setPublic256(b);
+        ctUint256 memory ctB = MpcCore.offBoard(gtB);
+        gtUint256 gtB2 = MpcCore.onBoard(ctB);
+        uint256 resultB = MpcCore.decrypt(gtB2);
+        require(resultB == b, "Value B test failed");
+        
+        // Test value C
+        gtUint256 gtC = MpcCore.setPublic256(c);
+        ctUint256 memory ctC = MpcCore.offBoard(gtC);
+        gtUint256 gtC2 = MpcCore.onBoard(ctC);
+        uint256 resultC = MpcCore.decrypt(gtC2);
+        require(resultC == c, "Value C test failed");
+        
+        return (resultA, resultB, resultC);
+    }
+
+    /**
+     * @dev Test onBoard with edge cases (0 and max)
+     */
+    function testOnBoardEdgeCases() public returns (uint256, uint256) {
+        // Test zero
+        uint256 zero = 0;
+        gtUint256 gtZero = MpcCore.setPublic256(zero);
+        ctUint256 memory ctZero = MpcCore.offBoard(gtZero);
+        gtUint256 gtZero2 = MpcCore.onBoard(ctZero);
+        uint256 resultZero = MpcCore.decrypt(gtZero2);
+        require(resultZero == zero, "Zero test failed");
+        
+        // Test max
+        uint256 max = type(uint256).max;
+        gtUint256 gtMax = MpcCore.setPublic256(max);
+        ctUint256 memory ctMax = MpcCore.offBoard(gtMax);
+        gtUint256 gtMax2 = MpcCore.onBoard(ctMax);
+        uint256 resultMax = MpcCore.decrypt(gtMax2);
+        require(resultMax == max, "Max test failed");
+        
+        return (resultZero, resultMax);
+    }
+
+    /**
+     * @dev Test onBoard with values that cross 128-bit boundary
+     */
+    function testOnBoard128BitBoundary() public returns (uint256, uint256) {
+        // Test value below 128-bit boundary (2^127 - 1)
+        uint256 below128 = (uint256(1) << 127) - 1;
+        gtUint256 gtBelow = MpcCore.setPublic256(below128);
+        ctUint256 memory ctBelow = MpcCore.offBoard(gtBelow);
+        gtUint256 gtBelow2 = MpcCore.onBoard(ctBelow);
+        uint256 resultBelow = MpcCore.decrypt(gtBelow2);
+        require(resultBelow == below128, "Below 128-bit test failed");
+        
+        // Test value above 128-bit boundary (2^128)
+        uint256 above128 = uint256(1) << 128;
+        gtUint256 gtAbove = MpcCore.setPublic256(above128);
+        ctUint256 memory ctAbove = MpcCore.offBoard(gtAbove);
+        gtUint256 gtAbove2 = MpcCore.onBoard(ctAbove);
+        uint256 resultAbove = MpcCore.decrypt(gtAbove2);
+        require(resultAbove == above128, "Above 128-bit test failed");
+        
+        return (resultBelow, resultAbove);
+    }
+}
+

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

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/**
+ * @title PrivacyImplementationV1
+ * @notice Implementation contract with privacy-preserving operations
+ * @dev To be used behind PrivacyProxy via delegatecall
+ */
+contract PrivacyImplementationV1 {
+    
+    // Storage layout must match proxy if needed
+    // Using mapping to avoid storage slot conflicts with proxy
+    mapping(address => gtUint128) private userBalances128;
+    mapping(address => gtUint256) private userBalances256;
+    
+    // Events
+    event ValueStored128(address indexed user);
+    event ValueStored256(address indexed user);
+    event OperationPerformed(address indexed user, string operation);
+    
+    /**
+     * @notice Store encrypted uint128 value for user
+     * @dev IT-type validation happens in delegatecall context
+     */
+    function storeValue128(itUint128 calldata value) external returns (ctUint128) {
+        // Validate IT-type (this runs in proxy's context via delegatecall)
+        gtUint128 gtValue = MpcCore.validateCiphertext(value);
+        
+        // Store in user's balance
+        userBalances128[msg.sender] = gtValue;
+        
+        emit ValueStored128(msg.sender);
+        
+        // Return encrypted for user
+        return MpcCore.offBoardToUser(gtValue, msg.sender);
+    }
+    
+    /**
+     * @notice Add to user's stored value (uint128)
+     */
+    function addToBalance128(itUint128 calldata amount) external returns (ctUint128) {
+        // Validate new amount
+        gtUint128 gtAmount = MpcCore.validateCiphertext(amount);
+        
+        // Get current balance
+        gtUint128 currentBalance = userBalances128[msg.sender];
+        
+        // Add to balance
+        gtUint128 newBalance = MpcCore.add(currentBalance, gtAmount);
+        
+        // Store new balance
+        userBalances128[msg.sender] = newBalance;
+        
+        emit OperationPerformed(msg.sender, "add128");
+        
+        // Return encrypted result
+        return MpcCore.offBoardToUser(newBalance, msg.sender);
+    }
+    
+    /**
+     * @notice Get user's balance (uint128)
+     */
+    function getBalance128() external returns (ctUint128) {
+        gtUint128 balance = userBalances128[msg.sender];
+        return MpcCore.offBoardToUser(balance, msg.sender);
+    }
+    
+    /**
+     * @notice Perform addition on two encrypted values (uint128)
+     */
+    function add128(itUint128 calldata a, itUint128 calldata b) external returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.add(gtA, gtB);
+        
+        emit OperationPerformed(msg.sender, "add128");
+        
+        return MpcCore.offBoardToUser(result, msg.sender);
+    }
+    
+    /**
+     * @notice Perform multiplication on two encrypted values (uint128)
+     */
+    function mul128(itUint128 calldata a, itUint128 calldata b) external returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint128 result = MpcCore.mul(gtA, gtB);
+        
+        emit OperationPerformed(msg.sender, "mul128");
+        
+        return MpcCore.offBoardToUser(result, msg.sender);
+    }
+    
+    /**
+     * @notice Store encrypted uint256 value for user
+     */
+    function storeValue256(itUint256 calldata value) external returns (ctUint256 memory) {
+        gtUint256 gtValue = MpcCore.validateCiphertext(value);
+        
+        userBalances256[msg.sender] = gtValue;
+        
+        emit ValueStored256(msg.sender);
+        
+        return MpcCore.offBoardToUser(gtValue, msg.sender);
+    }
+    
+    /**
+     * @notice Add to user's stored value (uint256)
+     */
+    function addToBalance256(itUint256 calldata amount) external returns (ctUint256 memory) {
+        gtUint256 gtAmount = MpcCore.validateCiphertext(amount);
+        
+        gtUint256 currentBalance = userBalances256[msg.sender];
+        
+        gtUint256 newBalance = MpcCore.add(currentBalance, gtAmount);
+        
+        userBalances256[msg.sender] = newBalance;
+        
+        emit OperationPerformed(msg.sender, "add256");
+        
+        return MpcCore.offBoardToUser(newBalance, msg.sender);
+    }
+    
+    /**
+     * @notice Get user's balance (uint256)
+     */
+    function getBalance256() external returns (ctUint256 memory) {
+        gtUint256 balance = userBalances256[msg.sender];
+        return MpcCore.offBoardToUser(balance, msg.sender);
+    }
+    
+    /**
+     * @notice Perform addition on two encrypted values (uint256)
+     */
+    function add256(itUint256 calldata a, itUint256 calldata b) external returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        
+        gtUint256 result = MpcCore.add(gtA, gtB);
+        
+        emit OperationPerformed(msg.sender, "add256");
+        
+        return MpcCore.offBoardToUser(result, msg.sender);
+    }
+    
+    /**
+     * @notice Get version of implementation
+     */
+    function version() external pure returns (string memory) {
+        return "v1";
+    }
+}
+

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

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/**
+ * @title PrivacyImplementationV2
+ * @notice Upgraded implementation with additional features
+ * @dev Storage layout must match V1 to preserve state
+ */
+contract PrivacyImplementationV2 {
+    
+    // Storage layout MUST match V1
+    mapping(address => gtUint128) private userBalances128;
+    mapping(address => gtUint256) private userBalances256;
+    
+    // Events
+    event ValueStored128(address indexed user);
+    event ValueStored256(address indexed user);
+    event OperationPerformed(address indexed user, string operation);
+    
+    // V1 functions (must keep same signatures for compatibility)
+    
+    function storeValue128(itUint128 calldata value) external returns (ctUint128) {
+        gtUint128 gtValue = MpcCore.validateCiphertext(value);
+        userBalances128[msg.sender] = gtValue;
+        emit ValueStored128(msg.sender);
+        return MpcCore.offBoardToUser(gtValue, msg.sender);
+    }
+    
+    function addToBalance128(itUint128 calldata amount) external returns (ctUint128) {
+        gtUint128 gtAmount = MpcCore.validateCiphertext(amount);
+        gtUint128 currentBalance = userBalances128[msg.sender];
+        gtUint128 newBalance = MpcCore.add(currentBalance, gtAmount);
+        userBalances128[msg.sender] = newBalance;
+        emit OperationPerformed(msg.sender, "add128");
+        return MpcCore.offBoardToUser(newBalance, msg.sender);
+    }
+    
+    function getBalance128() external returns (ctUint128) {
+        gtUint128 balance = userBalances128[msg.sender];
+        return MpcCore.offBoardToUser(balance, msg.sender);
+    }
+    
+    function add128(itUint128 calldata a, itUint128 calldata b) external returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        gtUint128 result = MpcCore.add(gtA, gtB);
+        emit OperationPerformed(msg.sender, "add128");
+        return MpcCore.offBoardToUser(result, msg.sender);
+    }
+    
+    function mul128(itUint128 calldata a, itUint128 calldata b) external returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        gtUint128 result = MpcCore.mul(gtA, gtB);
+        emit OperationPerformed(msg.sender, "mul128");
+        return MpcCore.offBoardToUser(result, msg.sender);
+    }
+    
+    function storeValue256(itUint256 calldata value) external returns (ctUint256 memory) {
+        gtUint256 gtValue = MpcCore.validateCiphertext(value);
+        userBalances256[msg.sender] = gtValue;
+        emit ValueStored256(msg.sender);
+        return MpcCore.offBoardToUser(gtValue, msg.sender);
+    }
+    
+    function addToBalance256(itUint256 calldata amount) external returns (ctUint256 memory) {
+        gtUint256 gtAmount = MpcCore.validateCiphertext(amount);
+        gtUint256 currentBalance = userBalances256[msg.sender];
+        gtUint256 newBalance = MpcCore.add(currentBalance, gtAmount);
+        userBalances256[msg.sender] = newBalance;
+        emit OperationPerformed(msg.sender, "add256");
+        return MpcCore.offBoardToUser(newBalance, msg.sender);
+    }
+    
+    function getBalance256() external returns (ctUint256 memory) {
+        gtUint256 balance = userBalances256[msg.sender];
+        return MpcCore.offBoardToUser(balance, msg.sender);
+    }
+    
+    function add256(itUint256 calldata a, itUint256 calldata b) external returns (ctUint256 memory) {
+        gtUint256 gtA = MpcCore.validateCiphertext(a);
+        gtUint256 gtB = MpcCore.validateCiphertext(b);
+        gtUint256 result = MpcCore.add(gtA, gtB);
+        emit OperationPerformed(msg.sender, "add256");
+        return MpcCore.offBoardToUser(result, msg.sender);
+    }
+    
+    // NEW V2 FUNCTIONS
+    
+    /**
+     * @notice Subtract from balance (NEW in V2)
+     */
+    function subtractFromBalance128(itUint128 calldata amount) external returns (ctUint128) {
+        gtUint128 gtAmount = MpcCore.validateCiphertext(amount);
+        gtUint128 currentBalance = userBalances128[msg.sender];
+        gtUint128 newBalance = MpcCore.sub(currentBalance, gtAmount);
+        userBalances128[msg.sender] = newBalance;
+        emit OperationPerformed(msg.sender, "sub128");
+        return MpcCore.offBoardToUser(newBalance, msg.sender);
+    }
+    
+    /**
+     * @notice Subtract two encrypted values (NEW in V2)
+     */
+    function sub128(itUint128 calldata a, itUint128 calldata b) external returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        gtUint128 result = MpcCore.sub(gtA, gtB);
+        emit OperationPerformed(msg.sender, "sub128");
+        return MpcCore.offBoardToUser(result, msg.sender);
+    }
+    
+    /**
+     * @notice Divide two encrypted values (NEW in V2)
+     */
+    function div128(itUint128 calldata a, itUint128 calldata b) external returns (ctUint128) {
+        gtUint128 gtA = MpcCore.validateCiphertext(a);
+        gtUint128 gtB = MpcCore.validateCiphertext(b);
+        gtUint128 result = MpcCore.div(gtA, gtB);
+        emit OperationPerformed(msg.sender, "div128");
+        return MpcCore.offBoardToUser(result, msg.sender);
+    }
+    
+    /**
+     * @notice Get version (upgraded)
+     */
+    function version() external pure returns (string memory) {
+        return "v2";
+    }
+}
+

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

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title PrivacyProxy
+ * @notice Simple upgradeable proxy that delegates all calls to an implementation contract
+ * @dev Tests if IT-type validation works through delegatecall
+ */
+contract PrivacyProxy {
+    
+    // Storage slot for implementation address (EIP-1967)
+    bytes32 private constant IMPLEMENTATION_SLOT = bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1);
+    
+    // Storage slot for admin address
+    bytes32 private constant ADMIN_SLOT = bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1);
+    
+    // Events
+    event Upgraded(address indexed implementation);
+    event AdminChanged(address previousAdmin, address newAdmin);
+    
+    /**
+     * @notice Constructor sets initial implementation and admin
+     */
+    constructor(address _implementation) {
+        _setImplementation(_implementation);
+        _setAdmin(msg.sender);
+    }
+    
+    /**
+     * @notice Modifier to restrict functions to admin only
+     */
+    modifier onlyAdmin() {
+        require(msg.sender == _getAdmin(), "PrivacyProxy: caller is not admin");
+        _;
+    }
+    
+    /**
+     * @notice Upgrade to a new implementation
+     * @param newImplementation Address of the new implementation contract
+     */
+    function upgradeTo(address newImplementation) external onlyAdmin {
+        _setImplementation(newImplementation);
+        emit Upgraded(newImplementation);
+    }
+    
+    /**
+     * @notice Change the admin
+     * @param newAdmin Address of the new admin
+     */
+    function changeAdmin(address newAdmin) external onlyAdmin {
+        address oldAdmin = _getAdmin();
+        _setAdmin(newAdmin);
+        emit AdminChanged(oldAdmin, newAdmin);
+    }
+    
+    /**
+     * @notice Get current implementation address
+     */
+    function implementation() external view returns (address) {
+        return _getImplementation();
+    }
+    
+    /**
+     * @notice Get current admin address
+     */
+    function admin() external view returns (address) {
+        return _getAdmin();
+    }
+    
+    /**
+     * @notice Fallback function delegates all calls to implementation
+     */
+    fallback() external payable {
+        address impl = _getImplementation();
+        require(impl != address(0), "PrivacyProxy: implementation not set");
+        
+        assembly {
+            // Copy msg.data to memory
+            calldatacopy(0, 0, calldatasize())
+            
+            // Delegatecall to implementation
+            let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)
+            
+            // Copy return data
+            returndatacopy(0, 0, returndatasize())
+            
+            // Return or revert based on delegatecall result
+            switch result
+            case 0 {
+                revert(0, returndatasize())
+            }
+            default {
+                return(0, returndatasize())
+            }
+        }
+    }
+    
+    /**
+     * @notice Receive function for ETH transfers
+     */
+    receive() external payable {}
+    
+    // Internal functions
+    
+    function _setImplementation(address newImplementation) private {
+        require(newImplementation != address(0), "PrivacyProxy: invalid implementation");
+        
+        bytes32 slot = IMPLEMENTATION_SLOT;
+        assembly {
+            sstore(slot, newImplementation)
+        }
+    }
+    
+    function _getImplementation() private view returns (address impl) {
+        bytes32 slot = IMPLEMENTATION_SLOT;
+        assembly {
+            impl := sload(slot)
+        }
+    }
+    
+    function _setAdmin(address newAdmin) private {
+        require(newAdmin != address(0), "PrivacyProxy: invalid admin");
+        
+        bytes32 slot = ADMIN_SLOT;
+        assembly {
+            sstore(slot, newAdmin)
+        }
+    }
+    
+    function _getAdmin() private view returns (address adm) {
+        bytes32 slot = ADMIN_SLOT;
+        assembly {
+            adm := sload(slot)
+        }
+    }
+}
+

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

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Random128TestsContract {
+    uint128 randomResult;
+    uint128 randomBoundedResult;
+
+    function getRandom() public view returns (uint128) {
+        return randomResult;
+    }
+
+    function getRandomBounded() public view returns (uint128) {
+        return randomBoundedResult;
+    }
+
+    function randomTest() public returns (uint128) {
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.rand128()));
+        randomResult = result;
+        
+        return result;
+    }
+
+    function randomBoundedTest(uint8 numBits) public returns (uint128) {
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.randBoundedBits128(numBits)));
+        randomBoundedResult = result;
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Random256TestsContract {
+    uint256 randomResult;
+    uint256 randomBoundedResult;
+
+    function getRandom() public view returns (uint256) {
+        return randomResult;
+    }
+
+    function getRandomBounded() public view returns (uint256) {
+        return randomBoundedResult;
+    }
+
+    function randomTest() public returns (uint256) {
+        uint256 result = MpcCore.decrypt(MpcCore.rand256());
+        randomResult = result;
+        
+        return result;
+    }
+
+    function randomBoundedTest(uint8 numBits) public returns (uint256) {
+        uint256 result = MpcCore.decrypt(MpcCore.randBoundedBits256(numBits));
+        randomBoundedResult = result;
+        
+        return result;
+    }
+}
+