@coti-io/coti-contracts 1.1.0 → 1.3.0

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;
+    }
+}
+

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

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Shift128TestsContract {
+    uint128 shlResult;
+    uint128 shrResult;
+
+    function getShlResult() public view returns (uint128) {
+        return shlResult;
+    }
+
+    function getShrResult() public view returns (uint128) {
+        return shrResult;
+    }
+
+    function shlTest(uint128 a, uint8 shift) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.shl(a128, shift)));
+        shlResult = result;
+        
+        return result;
+    }
+
+    function shrTest(uint128 a, uint8 shift) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        
+        uint128 result = uint128(MpcCore.decrypt(MpcCore.shr(a128, shift)));
+        shrResult = result;
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Shift256TestsContract {
+    uint256 shlResult;
+    uint256 shrResult;
+
+    function getShlResult() public view returns (uint256) {
+        return shlResult;
+    }
+
+    function getShrResult() public view returns (uint256) {
+        return shrResult;
+    }
+
+    function shlTest(uint256 a, uint8 shift) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.shl(a256, shift));
+        shlResult = result;
+        
+        return result;
+    }
+
+    function shrTest(uint256 a, uint8 shift) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        
+        uint256 result = MpcCore.decrypt(MpcCore.shr(a256, shift));
+        shrResult = result;
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Transfer128TestsContract {
+    uint128 newA;
+    uint128 newB;
+    bool result;
+
+    function getResults() public view returns (uint128, uint128, bool) {
+        return (newA, newB, result);
+    }
+
+    function transferTest(uint128 a, uint128 b, uint128 amount) public returns (uint128, uint128, bool) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        gtUint128 amount128 = MpcCore.setPublic128(amount);
+        
+        (gtUint128 newA128, gtUint128 newB128, gtBool res) = MpcCore.transfer(a128, b128, amount128);
+        
+        newA = uint128(MpcCore.decrypt(newA128));
+        newB = uint128(MpcCore.decrypt(newB128));
+        result = MpcCore.decrypt(res);
+        
+        return (newA, newB, result);
+    }
+}
+

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

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Transfer256TestsContract {
+    uint256 newA;
+    uint256 newB;
+    bool result;
+
+    function getResults() public view returns (uint256, uint256, bool) {
+        return (newA, newB, result);
+    }
+
+    function transferTest(uint256 a, uint256 b, uint256 amount) public returns (uint256, uint256, bool) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        gtUint256 amount256 = MpcCore.setPublic256(amount);
+        
+        (gtUint256 newA256, gtUint256 newB256, gtBool res) = MpcCore.transfer(a256, b256, amount256);
+        
+        newA = MpcCore.decrypt(newA256);
+        newB = MpcCore.decrypt(newB256);
+        result = MpcCore.decrypt(res);
+        
+        return (newA, newB, result);
+    }
+}
+

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

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract TransferWithAllowance128TestsContract {
+    uint128 newA;
+    uint128 newB;
+    bool result;
+    uint128 newAllowance;
+
+    function getResults() public view returns (uint128, uint128, bool, uint128) {
+        return (newA, newB, result, newAllowance);
+    }
+
+    function transferWithAllowanceTest(uint128 a, uint128 b, uint128 amount, uint128 allowance) public returns (uint128, uint128, bool, uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        gtUint128 amount128 = MpcCore.setPublic128(amount);
+        gtUint128 allowance128 = MpcCore.setPublic128(allowance);
+        
+        (gtUint128 newA128, gtUint128 newB128, gtBool res, gtUint128 newAllowance128) = MpcCore.transferWithAllowance(a128, b128, amount128, allowance128);
+        
+        newA = uint128(MpcCore.decrypt(newA128));
+        newB = uint128(MpcCore.decrypt(newB128));
+        result = MpcCore.decrypt(res);
+        newAllowance = uint128(MpcCore.decrypt(newAllowance128));
+        
+        return (newA, newB, result, newAllowance);
+    }
+}
+

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

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract TransferWithAllowance256TestsContract {
+    uint256 newA;
+    uint256 newB;
+    bool result;
+    uint256 newAllowance;
+
+    function getResults() public view returns (uint256, uint256, bool, uint256) {
+        return (newA, newB, result, newAllowance);
+    }
+
+    function transferWithAllowanceTest(uint256 a, uint256 b, uint256 amount, uint256 allowance) public returns (uint256, uint256, bool, uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        gtUint256 amount256 = MpcCore.setPublic256(amount);
+        gtUint256 allowance256 = MpcCore.setPublic256(allowance);
+        
+        (gtUint256 newA256, gtUint256 newB256, gtBool res, gtUint256 newAllowance256) = MpcCore.transferWithAllowance(a256, b256, amount256, allowance256);
+        
+        newA = MpcCore.decrypt(newA256);
+        newB = MpcCore.decrypt(newB256);
+        result = MpcCore.decrypt(res);
+        newAllowance = MpcCore.decrypt(newAllowance256);
+        
+        return (newA, newB, result, newAllowance);
+    }
+}
+