chore: add bitwise for euint256 in TFHEExecutor

Author: PacificYield

contracts/codegen/overloads.json

@@ -213,7 +213,7 @@ export const ALL_FHE_TYPES: FheType[] = [
   {
     type: 'Euint256',
     value: 8,
-    supportedOperators: ['eq', 'ne', 'rotr', 'rotr', 'select', 'rand', 'randBounded'],
+    supportedOperators: ['eq', 'ne', 'rotr', 'rotr', 'shr', 'shl', 'select', 'rand', 'randBounded'],
     bitLength: 256,
     clearMatchingType: 'uint256',
   },

contracts/codegen/types.ts

@@ -282,7 +282,7 @@ contract TFHEExecutorNoEvents is UUPSUpgradeable, Ownable2StepUpgradeable {
      * @return result       Result.
      */
     function fheShl(bytes32 lhs, bytes32 rhs, bytes1 scalarByte) public virtual returns (bytes32 result) {
-        uint256 supportedTypes = (1 << 2) + (1 << 3) + (1 << 4) + (1 << 5) + (1 << 6);
+        uint256 supportedTypes = (1 << 2) + (1 << 3) + (1 << 4) + (1 << 5) + (1 << 6) + (1 << 8);
         _requireType(lhs, supportedTypes);
         uint8 lhsType = _typeOf(lhs);
         bytes1 scalar = scalarByte & 0x01;
@@ -298,7 +298,7 @@ contract TFHEExecutorNoEvents is UUPSUpgradeable, Ownable2StepUpgradeable {
      * @return result       Result.
      */
     function fheShr(bytes32 lhs, bytes32 rhs, bytes1 scalarByte) public virtual returns (bytes32 result) {
-        uint256 supportedTypes = (1 << 2) + (1 << 3) + (1 << 4) + (1 << 5) + (1 << 6);
+        uint256 supportedTypes = (1 << 2) + (1 << 3) + (1 << 4) + (1 << 5) + (1 << 6) + (1 << 8);
         _requireType(lhs, supportedTypes);
         uint8 lhsType = _typeOf(lhs);
         bytes1 scalar = scalarByte & 0x01;

contracts/contracts/TFHEExecutorNoEvents.sol

@@ -202,6 +202,34 @@ contract TFHETestSuite7 {
         TFHE.allowThis(result);
         resEuint128 = result;
     }
+    function shl_euint256_euint8(einput a, einput b, bytes calldata inputProof) public {
+        euint256 aProc = TFHE.asEuint256(a, inputProof);
+        euint8 bProc = TFHE.asEuint8(b, inputProof);
+        euint256 result = TFHE.shl(aProc, bProc);
+        TFHE.allowThis(result);
+        resEuint256 = result;
+    }
+    function shl_euint256_uint8(einput a, uint8 b, bytes calldata inputProof) public {
+        euint256 aProc = TFHE.asEuint256(a, inputProof);
+        uint8 bProc = b;
+        euint256 result = TFHE.shl(aProc, bProc);
+        TFHE.allowThis(result);
+        resEuint256 = result;
+    }
+    function shr_euint256_euint8(einput a, einput b, bytes calldata inputProof) public {
+        euint256 aProc = TFHE.asEuint256(a, inputProof);
+        euint8 bProc = TFHE.asEuint8(b, inputProof);
+        euint256 result = TFHE.shr(aProc, bProc);
+        TFHE.allowThis(result);
+        resEuint256 = result;
+    }
+    function shr_euint256_uint8(einput a, uint8 b, bytes calldata inputProof) public {
+        euint256 aProc = TFHE.asEuint256(a, inputProof);
+        uint8 bProc = b;
+        euint256 result = TFHE.shr(aProc, bProc);
+        TFHE.allowThis(result);
+        resEuint256 = result;
+    }
     function rotr_euint256_euint8(einput a, einput b, bytes calldata inputProof) public {
         euint256 aProc = TFHE.asEuint256(a, inputProof);
         euint8 bProc = TFHE.asEuint8(b, inputProof);

contracts/examples/tests/TFHETestSuite7.sol

@@ -7481,6 +7481,52 @@ library TFHE {
         return euint128.wrap(Impl.rotr(euint128.unwrap(a), bytes32(uint256(b)), true));
     }
 
+    /**
+     * @dev Evaluates shl(euint256 a, euint8 b) and returns the result.
+     */
+    function shl(euint256 a, euint8 b) internal returns (euint256) {
+        if (!isInitialized(a)) {
+            a = asEuint256(0);
+        }
+        if (!isInitialized(b)) {
+            b = asEuint8(0);
+        }
+        return euint256.wrap(Impl.shl(euint256.unwrap(a), euint256.unwrap(asEuint256(b)), false));
+    }
+
+    /**
+     * @dev Evaluates shl(euint256 a, uint8) and returns the result.
+     */
+    function shl(euint256 a, uint8 b) internal returns (euint256) {
+        if (!isInitialized(a)) {
+            a = asEuint256(0);
+        }
+        return euint256.wrap(Impl.shl(euint256.unwrap(a), bytes32(uint256(b)), true));
+    }
+
+    /**
+     * @dev Evaluates shr(euint256 a, euint8 b) and returns the result.
+     */
+    function shr(euint256 a, euint8 b) internal returns (euint256) {
+        if (!isInitialized(a)) {
+            a = asEuint256(0);
+        }
+        if (!isInitialized(b)) {
+            b = asEuint8(0);
+        }
+        return euint256.wrap(Impl.shr(euint256.unwrap(a), euint256.unwrap(asEuint256(b)), false));
+    }
+
+    /**
+     * @dev Evaluates shr(euint256 a, uint8) and returns the result.
+     */
+    function shr(euint256 a, uint8 b) internal returns (euint256) {
+        if (!isInitialized(a)) {
+            a = asEuint256(0);
+        }
+        return euint256.wrap(Impl.shr(euint256.unwrap(a), bytes32(uint256(b)), true));
+    }
+
     /**
      * @dev Evaluates rotr(euint256 a, euint8 b) and returns the result.
      */