@coti-io/coti-contracts 1.1.0 → 1.3.0

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

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

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract CheckedArithmetic128WithOverflowBitTestsContract {
+    uint128 addResult;
+    uint128 subResult;
+    uint128 mulResult;
+    bool overflowBit;
+
+    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 getOverflowBit() public view returns (bool) {
+        return overflowBit;
+    }
+
+    function checkedAddWithOverflowBitTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        (gtBool overflow, gtUint128 gtResult) = MpcCore.checkedAddWithOverflowBit(a128, b128);
+        uint128 result = uint128(MpcCore.decrypt(gtResult));
+        overflowBit = MpcCore.decrypt(overflow);
+        addResult = result;
+        
+        return result;
+    }
+
+    function checkedSubWithOverflowBitTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        (gtBool overflow, gtUint128 gtResult) = MpcCore.checkedSubWithOverflowBit(a128, b128);
+        uint128 result = uint128(MpcCore.decrypt(gtResult));
+        overflowBit = MpcCore.decrypt(overflow);
+        subResult = result;
+        
+        return result;
+    }
+
+    function checkedMulWithOverflowBitTest(uint128 a, uint128 b) public returns (uint128) {
+        gtUint128 a128 = MpcCore.setPublic128(a);
+        gtUint128 b128 = MpcCore.setPublic128(b);
+        
+        (gtBool overflow, gtUint128 gtResult) = MpcCore.checkedMulWithOverflowBit(a128, b128);
+        uint128 result = uint128(MpcCore.decrypt(gtResult));
+        overflowBit = MpcCore.decrypt(overflow);
+        mulResult = result;
+        
+        return result;
+    }
+}
+

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

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract CheckedArithmetic256WithOverflowBitTestsContract {
+    uint256 addResult;
+    uint256 subResult;
+    uint256 mulResult;
+    bool overflowBit;
+
+    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 getOverflowBit() public view returns (bool) {
+        return overflowBit;
+    }
+
+    function checkedAddWithOverflowBitTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        (gtBool overflow, gtUint256 gtResult) = MpcCore.checkedAddWithOverflowBit(a256, b256);
+        uint256 result = MpcCore.decrypt(gtResult);
+        overflowBit = MpcCore.decrypt(overflow);
+        addResult = result;
+        
+        return result;
+    }
+
+    function checkedSubWithOverflowBitTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        (gtBool overflow, gtUint256 gtResult) = MpcCore.checkedSubWithOverflowBit(a256, b256);
+        uint256 result = MpcCore.decrypt(gtResult);
+        overflowBit = MpcCore.decrypt(overflow);
+        subResult = result;
+        
+        return result;
+    }
+
+    function checkedMulWithOverflowBitTest(uint256 a, uint256 b) public returns (uint256) {
+        gtUint256 a256 = MpcCore.setPublic256(a);
+        gtUint256 b256 = MpcCore.setPublic256(b);
+        
+        (gtBool overflow, gtUint256 gtResult) = MpcCore.checkedMulWithOverflowBit(a256, b256);
+        uint256 result = MpcCore.decrypt(gtResult);
+        overflowBit = MpcCore.decrypt(overflow);
+        mulResult = result;
+        
+        return result;
+    }
+}
+