@coti-io/coti-contracts 1.0.8 → 1.1.0

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

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Comparison128BitTestsContract {
+
+    bool[] public boolResults;
+    uint128[] public uintResults;
+
+    function eqTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.eq(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.eq(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.eq(gtA, b[i])));
+        }
+    }
+
+    function neTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.ne(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.ne(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.ne(gtA, b[i])));
+        }
+    }
+
+    function geTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.ge(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.ge(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.ge(gtA, b[i])));
+        }
+    }
+
+    function gtTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.gt(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.gt(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.gt(gtA, b[i])));
+        }
+    }
+
+    function leTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.le(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.le(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.le(gtA, b[i])));
+        }
+    }
+
+    function ltTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.lt(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.lt(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.lt(gtA, b[i])));
+        }
+    }
+
+    function minTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            uintResults[i] = MpcCore.decrypt(MpcCore.min(gtA, gtB));
+
+            assert(uintResults[i] == MpcCore.decrypt(MpcCore.min(a[i], gtB)));
+            assert(uintResults[i] == MpcCore.decrypt(MpcCore.min(gtA, b[i])));
+        }
+    }
+
+    function maxTest(uint128[] calldata a, uint128[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b[i]);
+            
+            uintResults[i] = MpcCore.decrypt(MpcCore.max(gtA, gtB));
+
+            assert(uintResults[i] == MpcCore.decrypt(MpcCore.max(a[i], gtB)));
+            assert(uintResults[i] == MpcCore.decrypt(MpcCore.max(gtA, b[i])));
+        }
+    }
+
+    function _resetBools(uint256 length) internal {
+        // Reset the booleans array
+        delete boolResults;
+        
+        // Resize the booleans array to match input length
+        for(uint i = 0; i < length; i++) {
+            boolResults.push(false);
+        }
+    }
+
+    function _resetNumbers(uint256 length) internal {
+        // Reset the numbers array
+        delete uintResults;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            uintResults.push(0);
+        }
+    }
+}

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

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Comparison256BitTestsContract {
+
+    bool[] public boolResults;
+    uint256[] public uintResults2;
+
+    function eqTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.eq(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.eq(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.eq(gtA, b[i])));
+        }
+    }
+
+    function neTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.ne(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.ne(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.ne(gtA, b[i])));
+        }
+    }
+
+    function geTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.ge(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.ge(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.ge(gtA, b[i])));
+        }
+    }
+
+    function gtTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.gt(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.gt(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.gt(gtA, b[i])));
+        }
+    }
+
+    function leTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.le(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.le(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.le(gtA, b[i])));
+        }
+    }
+
+    function ltTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetBools(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            boolResults[i] = MpcCore.decrypt(MpcCore.lt(gtA, gtB));
+
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.lt(a[i], gtB)));
+            assert(boolResults[i] == MpcCore.decrypt(MpcCore.lt(gtA, b[i])));
+        }
+    }
+
+    function minTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            uintResults2[i] = MpcCore.decrypt(MpcCore.min(gtA, gtB));
+
+            assert(uintResults2[i] == MpcCore.decrypt(MpcCore.min(a[i], gtB)));
+            assert(uintResults2[i] == MpcCore.decrypt(MpcCore.min(gtA, b[i])));
+        }
+    }
+
+    function maxTest(uint256[] calldata a, uint256[] calldata b) public {
+        require(a.length == b.length, "Input length mismatch");
+        
+        _resetNumbers2(a.length);
+
+        for (uint256 i = 0; i < a.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b[i]);
+            
+            uintResults2[i] = MpcCore.decrypt(MpcCore.max(gtA, gtB));
+
+            assert(uintResults2[i] == MpcCore.decrypt(MpcCore.max(a[i], gtB)));
+            assert(uintResults2[i] == MpcCore.decrypt(MpcCore.max(gtA, b[i])));
+        }
+    }
+
+    function _resetBools(uint256 length) internal {
+        // Reset the booleans array
+        delete boolResults;
+        
+        // Resize the booleans array to match input length
+        for(uint i = 0; i < length; i++) {
+            boolResults.push(false);
+        }
+    }
+
+    function _resetNumbers2(uint256 length) internal {
+        // Reset the numbers array
+        delete uintResults2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            uintResults2.push(0);
+        }
+    }
+}

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

@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Miscellaneous128BitTestsContract {
+
+    uint128[] public numbers;
+    ctUint128[] public ctNumbers;
+    uint128[] public a;
+    uint128[] public b;
+    bool[] public success;
+    uint128[] public allowance;
+
+    function validateCiphertextTest(itUint128[] calldata a_) public {
+        _resetNumbers(a_.length);
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint128 memory gtA = MpcCore.validateCiphertext(a_[i]);
+            
+            numbers[i] = MpcCore.decrypt(gtA);
+        }
+    }
+
+    function setPublicTest(uint128[] calldata a_) public {
+        _resetNumbers(a_.length);
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a_[i]);
+            
+            numbers[i] = MpcCore.decrypt(gtA);
+        }
+    }
+
+    function offBoardToUserTest(uint128[] calldata a_) public {
+        _resetCtNumbers(a_.length);
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a_[i]);
+            
+            ctNumbers[i] = MpcCore.offBoardToUser(gtA, msg.sender);
+        }
+    }
+
+    function randTest(uint256 length) public {
+        _resetNumbers(length);
+
+        for (uint256 i = 0; i < length; ++i) {
+            numbers[i] = MpcCore.decrypt(MpcCore.rand128());
+        }
+    }
+
+    function randBoundedBitsTest(uint8[] calldata numBits) public {
+        _resetNumbers(numBits.length);
+
+        for (uint256 i = 0; i < numBits.length; ++i) {
+            numbers[i] = MpcCore.decrypt(MpcCore.randBoundedBits128(numBits[i]));
+        }
+    }
+
+    function transferTest(
+        uint128[] calldata a_,
+        uint128[] calldata b_,
+        uint128[] calldata amount_
+    )
+        public
+    {
+        require(a_.length == b_.length && a_.length == amount_.length, "Input length mismatch");
+
+        _resetA(a_.length);
+        _resetB(a_.length);
+        _resetSuccess(a_.length);
+
+        gtBool gtSuccess;
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a_[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b_[i]);
+            gtUint128 memory gtAmount = MpcCore.setPublic128(amount_[i]);
+            
+            (gtA, gtB, gtSuccess) = MpcCore.transfer(gtA, gtB, gtAmount);
+
+            a[i] = MpcCore.decrypt(gtA);
+            b[i] = MpcCore.decrypt(gtB);
+            success[i] = MpcCore.decrypt(gtSuccess);
+        }
+    }
+
+    function transferWithAllowanceTest(
+        uint128[] calldata a_,
+        uint128[] calldata b_,
+        uint128[] calldata amount_,
+        uint128[] calldata allowance_
+    )
+        public
+    {
+        require(
+            a_.length == b_.length &&
+            a_.length == amount_.length &&
+            a_.length == allowance_.length,
+            "Input length mismatch"
+        );
+
+        _resetA(a_.length);
+        _resetB(a_.length);
+        _resetSuccess(a_.length);
+        _resetAllowance(a_.length);
+
+        gtBool gtSuccess;
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint128 memory gtA = MpcCore.setPublic128(a_[i]);
+            gtUint128 memory gtB = MpcCore.setPublic128(b_[i]);
+            gtUint128 memory gtAmount = MpcCore.setPublic128(amount_[i]);
+            gtUint128 memory gtAllowance = MpcCore.setPublic128(allowance_[i]);
+            
+            (gtA, gtB, gtSuccess, gtAllowance) = MpcCore.transferWithAllowance(gtA, gtB, gtAmount, gtAllowance);
+
+            a[i] = MpcCore.decrypt(gtA);
+            b[i] = MpcCore.decrypt(gtB);
+            success[i] = MpcCore.decrypt(gtSuccess);
+            allowance[i] = MpcCore.decrypt(gtAllowance);
+        }
+    }
+
+    function _resetNumbers(uint256 length) internal {
+        // Reset the numbers array
+        delete numbers;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbers.push(0);
+        }
+    }
+
+    function _resetCtNumbers(uint256 length) internal {
+        // Reset the numbers array
+        delete ctNumbers;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            ctNumbers.push(ctUint128(ctUint64.wrap(0), ctUint64.wrap(0)));
+        }
+    }
+
+    function _resetA(uint256 length) internal {
+        // Reset the numbers array
+        delete a;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            a.push(0);
+        }
+    }
+
+    function _resetB(uint256 length) internal {
+        // Reset the numbers array
+        delete b;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            b.push(0);
+        }
+    }
+
+    function _resetSuccess(uint256 length) internal {
+        // Reset the numbers array
+        delete success;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            success.push(false);
+        }
+    }
+
+    function _resetAllowance(uint256 length) internal {
+        // Reset the numbers array
+        delete allowance;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            allowance.push(0);
+        }
+    }
+}

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

@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract Miscellaneous256BitTestsContract {
+
+    uint256[] public numbers2;
+    ctUint256[] public ctNumbers2;
+    uint256[] public a2;
+    uint256[] public b2;
+    bool[] public success;
+    uint256[] public allowance2;
+
+    function validateCiphertextTest(itUint256[] calldata a_) public {
+        _resetNumbers2(a_.length);
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint256 memory gtA = MpcCore.validateCiphertext(a_[i]);
+            
+            numbers2[i] = MpcCore.decrypt(gtA);
+        }
+    }
+
+    function setPublicTest(uint256[] calldata a_) public {
+        _resetNumbers2(a_.length);
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a_[i]);
+            
+            numbers2[i] = MpcCore.decrypt(gtA);
+        }
+    }
+
+    function offBoardToUserTest(uint256[] calldata a_) public {
+        _resetCtNumbers2(a_.length);
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a_[i]);
+            
+            ctNumbers2[i] = MpcCore.offBoardToUser(gtA, msg.sender);
+        }
+    }
+
+    function randTest2(uint256 length) public {
+        _resetNumbers2(length);
+
+        for (uint256 i = 0; i < length; ++i) {
+            numbers2[i] = MpcCore.decrypt(MpcCore.rand256());
+        }
+    }
+
+    function randBoundedBitsTest2(uint8[] calldata numBits) public {
+        _resetNumbers2(numBits.length);
+
+        for (uint256 i = 0; i < numBits.length; ++i) {
+            numbers2[i] = MpcCore.decrypt(MpcCore.randBoundedBits256(numBits[i]));
+        }
+    }
+
+    function transferTest(
+        uint256[] calldata a_,
+        uint256[] calldata b_,
+        uint256[] calldata amount_
+    )
+        public
+    {
+        require(a_.length == b_.length && a_.length == amount_.length, "Input length mismatch");
+
+        _resetA2(a_.length);
+        _resetB2(a_.length);
+        _resetSuccess(a_.length);
+
+        gtBool gtSuccess;
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a_[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b_[i]);
+            gtUint256 memory gtAmount = MpcCore.setPublic256(amount_[i]);
+            
+            (gtA, gtB, gtSuccess) = MpcCore.transfer(gtA, gtB, gtAmount);
+
+            a2[i] = MpcCore.decrypt(gtA);
+            b2[i] = MpcCore.decrypt(gtB);
+            success[i] = MpcCore.decrypt(gtSuccess);
+        }
+    }
+
+    function transferWithAllowanceTest(
+        uint256[] calldata a_,
+        uint256[] calldata b_,
+        uint256[] calldata amount_,
+        uint256[] calldata allowance_
+    )
+        public
+    {
+        require(
+            a_.length == b_.length &&
+            a_.length == amount_.length &&
+            a_.length == allowance_.length,
+            "Input length mismatch"
+        );
+
+        _resetA2(a_.length);
+        _resetB2(a_.length);
+        _resetSuccess(a_.length);
+        _resetAllowance2(a_.length);
+
+        gtBool gtSuccess;
+
+        for (uint256 i = 0; i < a_.length; ++i) {
+            gtUint256 memory gtA = MpcCore.setPublic256(a_[i]);
+            gtUint256 memory gtB = MpcCore.setPublic256(b_[i]);
+            gtUint256 memory gtAmount = MpcCore.setPublic256(amount_[i]);
+            gtUint256 memory gtAllowance = MpcCore.setPublic256(allowance_[i]);
+            
+            (gtA, gtB, gtSuccess, gtAllowance) = MpcCore.transferWithAllowance(gtA, gtB, gtAmount, gtAllowance);
+
+            a2[i] = MpcCore.decrypt(gtA);
+            b2[i] = MpcCore.decrypt(gtB);
+            success[i] = MpcCore.decrypt(gtSuccess);
+            allowance2[i] = MpcCore.decrypt(gtAllowance);
+        }
+    }
+
+    function _resetNumbers2(uint256 length) internal {
+        // Reset the numbers array
+        delete numbers2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            numbers2.push(0);
+        }
+    }
+
+    function _resetCtNumbers2(uint256 length) internal {
+        // Reset the numbers array
+        delete ctNumbers2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            ctNumbers2.push(
+                ctUint256(
+                    ctUint128(ctUint64.wrap(0), ctUint64.wrap(0)),
+                    ctUint128(ctUint64.wrap(0), ctUint64.wrap(0))
+                )
+            );
+        }
+    }
+
+    function _resetA2(uint256 length) internal {
+        // Reset the numbers array
+        delete a2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            a2.push(0);
+        }
+    }
+
+    function _resetB2(uint256 length) internal {
+        // Reset the numbers array
+        delete b2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            b2.push(0);
+        }
+    }
+
+    function _resetSuccess(uint256 length) internal {
+        // Reset the numbers array
+        delete success;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            success.push(false);
+        }
+    }
+
+    function _resetAllowance2(uint256 length) internal {
+        // Reset the numbers array
+        delete allowance2;
+        
+        // Resize the numbers array to match input length
+        for(uint i = 0; i < length; i++) {
+            allowance2.push(0);
+        }
+    }
+}