@coti-io/coti-contracts 1.1.0 → 1.2.0

package/contracts/mocks/token/ERC20Mock.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/**
+ * @dev Mock ERC20 token for testing
+ */
+contract ERC20Mock is ERC20 {
+    constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
+
+    function mint(address to, uint256 amount) external {
+        _mint(to, amount);
+    }
+
+    function burn(address from, uint256 amount) external {
+        _burn(from, amount);
+    }
+}

package/contracts/mocks/token/PrivateERC20/EncryptedTokenReceiverMock.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../token/PrivateERC20/ITokenReceiverEncrypted.sol";
+
+contract EncryptedTokenReceiverMock is ITokenReceiverEncrypted {
+    bool public accept;
+
+    constructor(bool accept_) {
+        accept = accept_;
+    }
+
+    function onPrivateTransferReceived(address, bytes calldata) external view returns (bool) {
+        return accept;
+    }
+}
+

package/contracts/mocks/token/PrivateERC20/PrivacyBridgeERC20Mock.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../privacyBridge/PrivacyBridgeERC20.sol";
+
+/**
+ * @dev Mock contract for testing PrivacyBridgeERC20
+ */
+contract PrivacyBridgeERC20Mock is PrivacyBridgeERC20 {
+    constructor(address _token, address _privateToken) 
+        PrivacyBridgeERC20(_token, _privateToken) 
+    {}
+}

package/contracts/mocks/token/PrivateERC20/PrivateERC20AuditorSupplyMock.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../token/PrivateERC20/PrivateERC20.sol";
+import "../../../utils/mpc/MpcCore.sol";
+
+/**
+ * @title PrivateERC20AuditorSupplyMock
+ * @notice Example (audit issue #5, “option 3”): keep {totalSupply} privacy-preserving (returns 0 in the
+ *         base contract) while a **designated auditor** obtains **aggregate supply re-encrypted** to their key.
+ *         The default product stance for #5 “option 1” is **documentation only** — see {PrivateERC20} and
+ *         {IPrivateERC20} NatSpec for `totalSupply` / {supplyCap}; this contract illustrates an optional extension.
+ * @dev Flow:
+ *      1. Deploy with `auditor` = EOA (or a contract that has called `setAccountEncryptionAddress`).
+ *      2. Auditor calls `setAccountEncryptionAddress` if they use a dedicated off-chain key address.
+ *      3. Auditor calls `totalSupplyCiphertextForAuditor()` and decrypts off-chain — not plaintext on-chain.
+ *      For testing mints, grant `MINTER_ROLE` to a test account or use a deploy script; this mock does not add a public minter.
+ */
+contract PrivateERC20AuditorSupplyMock is PrivateERC20 {
+    address public immutable auditor;
+
+    error OnlyAuditor();
+    error AuditorCannotReceiveUserCiphertext();
+
+    constructor(address auditor_) PrivateERC20("PrivateERC20AuditorSupplyMock", "PAS") {
+        if (auditor_ == address(0)) revert ERC20InvalidReceiver(address(0));
+        auditor = auditor_;
+    }
+
+    /**
+     * @notice Returns aggregate supply as ciphertext under the auditor’s encryption address (see {_getAccountEncryptionAddress}).
+     * @dev Reverts if `msg.sender` is not `auditor`. Contract auditors without an AES key (`encryptionAddress == 0`) cannot use this path.
+     */
+    function totalSupplyCiphertextForAuditor() external nonReentrant returns (ctUint256 memory) {
+        if (msg.sender != auditor) revert OnlyAuditor();
+
+        address enc = _getAccountEncryptionAddress(auditor);
+        if (enc == address(0)) revert AuditorCannotReceiveUserCiphertext();
+
+        gtUint256 gtTotal = _getTotalSupplyGarbled();
+        return MpcCore.offBoardToUser(gtTotal, enc);
+    }
+}

package/contracts/mocks/token/PrivateERC20/PrivateERC20CappedMock.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../token/PrivateERC20/PrivateERC20.sol";
+
+/// @dev Minimal capped token for testing {supplyCap} enforcement in {_update}.
+contract PrivateERC20CappedMock is PrivateERC20 {
+    uint256 private immutable _cap;
+
+    constructor(uint256 cap_) PrivateERC20("PrivateERC20CappedMock", "PECAP") {
+        _cap = cap_;
+    }
+
+    function decimals() public pure override returns (uint8) {
+        return 6;
+    }
+
+    function supplyCap() public view override returns (uint256) {
+        return _cap;
+    }
+}
+

package/contracts/mocks/token/PrivateERC20/PrivateERC20GtCallerMock.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../token/PrivateERC20/IPrivateERC20.sol";
+import "../../../utils/mpc/MpcCore.sol";
+
+/**
+ * @dev Helper that calls the GT overloads using `MpcCore.setPublic256(amount)` to build a gtUint256.
+ * Used to test the GT entrypoints without needing an off-chain gtUint256 constructor.
+ */
+contract PrivateERC20GtCallerMock {
+    function transferGT(address token, address to, uint256 amount) external {
+        IPrivateERC20(token).transferGT(to, MpcCore.setPublic256(amount));
+    }
+
+    function approveGT(address token, address spender, uint256 amount) external {
+        IPrivateERC20(token).approveGT(spender, MpcCore.setPublic256(amount));
+    }
+
+    function transferFromGT(address token, address from, address to, uint256 amount) external {
+        IPrivateERC20(token).transferFromGT(from, to, MpcCore.setPublic256(amount));
+    }
+
+    function burnGt(address token, uint256 amount) external {
+        IPrivateERC20(token).burnGt(MpcCore.setPublic256(amount));
+    }
+}
+

package/contracts/mocks/token/PrivateERC20/PrivateERC20Mock.sol

@@ -3,15 +3,20 @@
 pragma solidity ^0.8.19;
 
 import "../../../token/PrivateERC20/PrivateERC20.sol";
+import "../../../utils/mpc/MpcCore.sol";
 
 contract PrivateERC20Mock is PrivateERC20 {
     constructor() PrivateERC20("PrivateERC20Mock", "PE20M") {}
 
-    function mint(address account, uint64 amount) external {
-        _mint(account, MpcCore.setPublic64(amount));
+    function decimals() public pure override returns (uint8) {
+        return 6;
     }
 
-    function burn(address account, uint64 amount) external {
-        _burn(account, MpcCore.setPublic64(amount));
+    function mint(address account, uint256 amount) public override nonReentrant {
+        _mint(account, MpcCore.setPublic256(amount));
+    }
+
+    function burn(address account, uint256 amount) public nonReentrant {
+        _burn(account, MpcCore.setPublic256(amount));
     }
 }

package/contracts/mocks/token/PrivateERC20/PrivateERC20ReentrantReceiverMock.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../token/PrivateERC20/ITokenReceiverEncrypted.sol";
+
+interface IPrivateERC20TransferAndCallEncrypted {
+    function transferAndCall(
+        address to,
+        bytes calldata itUint256Value,
+        bytes calldata data
+    ) external;
+}
+
+/**
+ * @dev Receiver that attempts to re-enter the token during {transferAndCall} encrypted callback.
+ * Used to test {ReentrancyGuard} in PrivateERC20.
+ */
+contract PrivateERC20ReentrantReceiverMock is ITokenReceiverEncrypted {
+    address public token;
+    bool public tryReenter;
+    bytes public reenterCalldata;
+
+    function configure(address token_, bool tryReenter_, bytes calldata reenterCalldata_) external {
+        token = token_;
+        tryReenter = tryReenter_;
+        reenterCalldata = reenterCalldata_;
+    }
+
+    function onPrivateTransferReceived(address, bytes calldata) external returns (bool) {
+        if (tryReenter && token != address(0)) {
+            // Low-level call to avoid needing full interface/types here.
+            (bool ok, ) = token.call(reenterCalldata);
+            ok; // ignore; we only care that the outer tx reverts or not
+        }
+        return true;
+    }
+}
+

package/contracts/mocks/token/PrivateERC20/PublicReentrantTokenReceiverMock.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../token/PrivateERC20/ITokenReceiver.sol";
+
+/**
+ * @dev Public-amount receiver that attempts to re-enter the token during `transferAndCall(uint256)` callback.
+ */
+contract PublicReentrantTokenReceiverMock is ITokenReceiver {
+    address public token;
+    bool public tryReenter;
+    bytes public reenterCalldata;
+
+    function configure(address token_, bool tryReenter_, bytes calldata reenterCalldata_) external {
+        token = token_;
+        tryReenter = tryReenter_;
+        reenterCalldata = reenterCalldata_;
+    }
+
+    function onTokenReceived(address, uint256, bytes calldata) external returns (bool) {
+        if (tryReenter && token != address(0)) {
+            (bool ok, ) = token.call(reenterCalldata);
+            ok;
+        }
+        return true;
+    }
+}
+

package/contracts/mocks/token/PrivateERC20/PublicTokenReceiverBoolMock.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../token/PrivateERC20/ITokenReceiver.sol";
+
+contract PublicTokenReceiverBoolMock is ITokenReceiver {
+    bool public accept;
+
+    constructor(bool accept_) {
+        accept = accept_;
+    }
+
+    function onTokenReceived(address, uint256, bytes calldata) external view returns (bool) {
+        return accept;
+    }
+}
+

package/contracts/mocks/token/PrivateERC20/PublicTokenReceiverMock.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../token/PrivateERC20/ITokenReceiver.sol";
+
+contract PublicTokenReceiverMock is ITokenReceiver {
+    function onTokenReceived(address, uint256, bytes calldata) external pure returns (bool) {
+        return true;
+    }
+}
+

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

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Arithmetic128TestsContract {
+    uint128 addResult;
+    uint128 subResult;
+    uint128 mulResult;
+    uint128 divResult;
+    uint128 remResult;
+
+    function getAddResult() public view returns (uint128) {
+        return addResult;
+    }
+
+    function getSubResult() public view returns (uint128) {
+        return subResult;
+    }
+
+    function getMulResult() public view returns (uint128) {
+        return mulResult;
+    }
+
+    function getDivResult() public view returns (uint128) {
+        return divResult;
+    }
+
+    function getRemResult() public view returns (uint128) {
+        return remResult;
+    }
+
+    function addTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.add(a128, b128)));
+        addResult = result;
+        
+        // Verify with scalar operations
+        require(result == uint128(MpcCore.decrypt(MpcCore.add(a, b128))), "addTest: scalar failed");
+        require(result == uint128(MpcCore.decrypt(MpcCore.add(a128, b))), "addTest: scalar failed");
+        
+        return result;
+    }
+
+    function checkedAddTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.checkedAdd(a128, b128)));
+        addResult = result;
+        
+        return result;
+    }
+
+    function subTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.sub(a128, b128)));
+        subResult = result;
+        
+        require(result == uint128(MpcCore.decrypt(MpcCore.sub(a, b128))), "subTest: scalar failed");
+        require(result == uint128(MpcCore.decrypt(MpcCore.sub(a128, b))), "subTest: scalar failed");
+        
+        return result;
+    }
+
+    function checkedSubTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.checkedSub(a128, b128)));
+        subResult = result;
+        
+        return result;
+    }
+
+    function mulTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.mul(a128, b128)));
+        mulResult = result;
+        
+        require(result == uint128(MpcCore.decrypt(MpcCore.mul(a, b128))), "mulTest: scalar failed");
+        require(result == uint128(MpcCore.decrypt(MpcCore.mul(a128, b))), "mulTest: scalar failed");
+        
+        return result;
+    }
+
+    function checkedMulTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.checkedMul(a128, b128)));
+        mulResult = result;
+        
+        return result;
+    }
+
+    function divTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.div(a128, b128)));
+        divResult = result;
+        
+        return result;
+    }
+
+    function remTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.rem(a128, b128)));
+        remResult = result;
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Arithmetic256TestsContract {
+    uint256 addResult;
+    uint256 subResult;
+    uint256 mulResult;
+    uint256 divResult;
+    uint256 remResult;
+
+    function getAddResult() public view returns (uint256) {
+        return addResult;
+    }
+
+    function getSubResult() public view returns (uint256) {
+        return subResult;
+    }
+
+    function getMulResult() public view returns (uint256) {
+        return mulResult;
+    }
+
+    function getDivResult() public view returns (uint256) {
+        return divResult;
+    }
+
+    function getRemResult() public view returns (uint256) {
+        return remResult;
+    }
+
+    function addTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.add(a256, b256));
+        addResult = result;
+        
+        // Verify with scalar operations
+        require(result == MpcCore.decrypt(MpcCore.add(a, b256)), "addTest: scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.add(a256, b)), "addTest: scalar failed");
+        
+        return result;
+    }
+
+    function checkedAddTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.checkedAdd(a256, b256));
+        addResult = result;
+        
+        return result;
+    }
+
+    function subTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.sub(a256, b256));
+        subResult = result;
+        
+        require(result == MpcCore.decrypt(MpcCore.sub(a, b256)), "subTest: scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.sub(a256, b)), "subTest: scalar failed");
+        
+        return result;
+    }
+
+    function checkedSubTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.checkedSub(a256, b256));
+        subResult = result;
+        
+        return result;
+    }
+
+    function mulTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.mul(a256, b256));
+        mulResult = result;
+        
+        require(result == MpcCore.decrypt(MpcCore.mul(a, b256)), "mulTest: scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.mul(a256, b)), "mulTest: scalar failed");
+        
+        return result;
+    }
+
+    function checkedMulTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.checkedMul(a256, b256));
+        mulResult = result;
+        
+        return result;
+    }
+
+    function divTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.div(a256, b256));
+        divResult = result;
+        
+        return result;
+    }
+
+    function remTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.rem(a256, b256));
+        remResult = result;
+        
+        return result;
+    }
+}

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

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Bitwise128TestsContract {
+    uint128 andResult;
+    uint128 orResult;
+    uint128 xorResult;
+
+    function getAndResult() public view returns (uint128) {
+        return andResult;
+    }
+
+    function getOrResult() public view returns (uint128) {
+        return orResult;
+    }
+
+    function getXorResult() public view returns (uint128) {
+        return xorResult;
+    }
+
+    function andTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.and(a128, b128)));
+        andResult = result;
+        
+        require(result == uint128(MpcCore.decrypt(MpcCore.and(a, b128))), "andTest: scalar failed");
+        require(result == uint128(MpcCore.decrypt(MpcCore.and(a128, b))), "andTest: scalar failed");
+        
+        return result;
+    }
+
+    function orTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.or(a128, b128)));
+        orResult = result;
+        
+        require(result == uint128(MpcCore.decrypt(MpcCore.or(a, b128))), "orTest: scalar failed");
+        require(result == uint128(MpcCore.decrypt(MpcCore.or(a128, b))), "orTest: scalar failed");
+        
+        return result;
+    }
+
+    function xorTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.xor(a128, b128)));
+        xorResult = result;
+        
+        require(result == uint128(MpcCore.decrypt(MpcCore.xor(a, b128))), "xorTest: scalar failed");
+        require(result == uint128(MpcCore.decrypt(MpcCore.xor(a128, b))), "xorTest: scalar failed");
+        
+        return result;
+    }
+
+    // Note: NOT operation is not supported for 128-bit and 256-bit types in the MPC precompile
+    // It only supports NOT for boolean types
+}
+

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

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Bitwise256TestsContract {
+    uint256 andResult;
+    uint256 orResult;
+    uint256 xorResult;
+
+    function getAndResult() public view returns (uint256) {
+        return andResult;
+    }
+
+    function getOrResult() public view returns (uint256) {
+        return orResult;
+    }
+
+    function getXorResult() public view returns (uint256) {
+        return xorResult;
+    }
+
+    function andTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.and(a256, b256));
+        andResult = result;
+        
+        require(result == MpcCore.decrypt(MpcCore.and(a, b256)), "andTest: scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.and(a256, b)), "andTest: scalar failed");
+        
+        return result;
+    }
+
+    function orTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.or(a256, b256));
+        orResult = result;
+        
+        require(result == MpcCore.decrypt(MpcCore.or(a, b256)), "orTest: scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.or(a256, b)), "orTest: scalar failed");
+        
+        return result;
+    }
+
+    function xorTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.xor(a256, b256));
+        xorResult = result;
+        
+        require(result == MpcCore.decrypt(MpcCore.xor(a, b256)), "xorTest: scalar failed");
+        require(result == MpcCore.decrypt(MpcCore.xor(a256, b)), "xorTest: scalar failed");
+        
+        return result;
+    }
+
+    // Note: NOT operation is not supported for 128-bit and 256-bit types in the MPC precompile
+    // It only supports NOT for boolean types
+}
+